LLM Evaluation

Evaluate Large Language Model (LLM) systems using automated metrics, LLM-as-judge patterns, and standardized benchmarks to ensure production quality and safety.

When to Use This Skill

Apply this skill when:

• Testing individual prompts for correctness and formatting
• Validating RAG (Retrieval-Augmented Generation) pipeline quality
• Measuring hallucinations, bias, or toxicity in LLM outputs
• Comparing different models or prompt configurations (A/B testing)
• Running benchmark tests (MMLU, HumanEval) to assess model capabilities
• Setting up production monitoring for LLM applications
• Integrating LLM quality checks into CI/CD pipelines

Common triggers:

• "How do I test if my RAG system is working correctly?"
• "How can I measure hallucinations in LLM outputs?"
• "What metrics should I use to evaluate generation quality?"
• "How do I compare GPT-4 vs Claude for my use case?"
• "How do I detect bias in LLM responses?"

Evaluation Strategy Selection

Decision Framework: Which Evaluation Approach?

By Task Type:

By Volume and Cost:

Layered Approach (Recommended for Production):

1. Layer 1: Automated metrics for all outputs (fast, cheap)
2. Layer 2: LLM-as-judge for 10% sample (nuanced quality)
3. Layer 3: Human review for 1% edge cases (validation)

Core Evaluation Patterns

Unit Evaluation (Individual Prompts)

Test single prompt-response pairs for correctness.

Methods:

• Exact Match: Response exactly matches expected output
• Regex Matching: Response follows expected pattern
• JSON Schema Validation: Structured output validation
• Keyword Presence: Required terms appear in response
• LLM-as-Judge: Binary pass/fail using evaluation prompt

Example Use Cases:

• Email classification (spam/not spam)
• Entity extraction (dates, names, locations)
• JSON output formatting validation
• Sentiment analysis (positive/negative/neutral)

Quick Start (Python):

import pytest
from openai import OpenAI

client = OpenAI()

def classify_sentiment(text: str) -> str:
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "Classify sentiment as positive, negative, or neutral. Return only the label."},
            {"role": "user", "content": text}
        ],
        temperature=0
    )
    return response.choices[0].message.content.strip().lower()

def test_positive_sentiment():
    result = classify_sentiment("I love this product!")
    assert result == "positive"

For complete unit evaluation examples, see examples/python/unit_evaluation.py and examples/typescript/unit-evaluation.ts.

RAG (Retrieval-Augmented Generation) Evaluation

Evaluate RAG systems using RAGAS framework metrics.

Critical Metrics (Priority Order):

1. Faithfulness (Target: > 0.8) - MOST CRITICAL

   • Measures: Is the answer grounded in retrieved context?
   • Prevents hallucinations
   • If failing: Adjust prompt to emphasize grounding, require citations

2. Answer Relevance (Target: > 0.7)

   • Measures: How well does the answer address the query?
   • If failing: Improve prompt instructions, add few-shot examples

3. Context Relevance (Target: > 0.7)

   • Measures: Are retrieved chunks relevant to the query?
   • If failing: Improve retrieval (better embeddings, hybrid search)

4. Context Precision (Target: > 0.5)

   • Measures: Are relevant chunks ranked higher than irrelevant?
   • If failing: Add re-ranking step to retrieval pipeline

5. Context Recall (Target: > 0.8)

   • Measures: Are all relevant chunks retrieved?
   • If failing: Increase retrieval count, improve chunking strategy

Quick Start (Python with RAGAS):

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_relevancy
from datasets import Dataset

data = {
    "question": ["What is the capital of France?"],
    "answer": ["The capital of France is Paris."],
    "contexts": [["Paris is the capital of France."]],
    "ground_truth": ["Paris"]
}

dataset = Dataset.from_dict(data)
results = evaluate(dataset, metrics=[faithfulness, answer_relevancy, context_relevancy])
print(f"Faithfulness: {results['faithfulness']:.2f}")

For comprehensive RAG evaluation patterns, see references/rag-evaluation.md and examples/python/ragas_example.py.

LLM-as-Judge Evaluation

Use powerful LLMs (GPT-4, Claude Opus) to evaluate other LLM outputs.

When to Use:

• Generation quality assessment (summaries, creative writing)
• Nuanced evaluation criteria (tone, clarity, helpfulness)
• Custom rubrics for domain-specific tasks
• Medium-volume evaluation (100-1,000 samples)

Correlation with Human Judgment: 0.75-0.85 for well-designed rubrics

Best Practices:

• Use clear, specific rubrics (1-5 scale with detailed criteria)
• Include few-shot examples in evaluation prompt
• Average multiple evaluations to reduce variance
• Be aware of biases (position bias, verbosity bias, self-preference)

Quick Start (Python):

from openai import OpenAI

client = OpenAI()

def evaluate_quality(prompt: str, response: str) -> tuple[int, str]:
    """Returns (score 1-5, reasoning)"""
    eval_prompt = f"""
Rate the following LLM response on relevance and helpfulness.

USER PROMPT: {prompt}
LLM RESPONSE: {response}

Provide:
Score: [1-5, where 5 is best]
Reasoning: [1-2 sentences]
"""
    result = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": eval_prompt}],
        temperature=0.3
    )
    content = result.choices[0].message.content
    lines = content.strip().split('\n')
    score = int(lines[0].split(':')[1].strip())
    reasoning = lines[1].split(':', 1)[1].strip()
    return score, reasoning

For detailed LLM-as-judge patterns and prompt templates, see references/llm-as-judge.md and examples/python/llm_as_judge.py.

Safety and Alignment Evaluation

Measure hallucinations, bias, and toxicity in LLM outputs.

Hallucination Detection

Methods:

1. Faithfulness to Context (RAG):

   • Use RAGAS faithfulness metric
   • LLM checks if claims are supported by context
   • Score: Supported claims / Total claims

2. Factual Accuracy (Closed-Book):

   • LLM-as-judge with access to reliable sources
   • Fact-checking APIs (Google Fact Check)
   • Entity-level verification (dates, names, statistics)

3. Self-Consistency:

   • Generate multiple responses to same question
   • Measure agreement between responses
   • Low consistency suggests hallucination

Bias Evaluation

Types of Bias:

• Gender bias (stereotypical associations)
• Racial/ethnic bias (discriminatory outputs)
• Cultural bias (Western-centric assumptions)
• Age/disability bias (ableist or ageist language)

Evaluation Methods:

1. Stereotype Tests:

   • BBQ (Bias Benchmark for QA): 58,000 question-answer pairs
   • BOLD (Bias in Open-Ended Language Generation)

2. Counterfactual Evaluation:

   • Generate responses with demographic swaps
   • Example: "Dr. Smith (he/she) recommended..." → compare outputs
   • Measure consistency across variations

Toxicity Detection

Tools:

• Perspective API (Google): Toxicity, threat, insult scores
• Detoxify (HuggingFace): Open-source toxicity classifier
• OpenAI Moderation API: Hate, harassment, violence detection

For comprehensive safety evaluation patterns, see references/safety-evaluation.md.

Benchmark Testing

Assess model capabilities using standardized benchmarks.

Standard Benchmarks:

Domain-Specific Benchmarks:

• Medical: MedQA (USMLE), PubMedQA
• Legal: LegalBench
• Finance: FinQA, ConvFinQA

When to Use Benchmarks:

• Comparing multiple models (GPT-4 vs Claude vs Llama)
• Model selection for specific domains
• Baseline capability assessment
• Academic research and publication

Quick Start (lm-evaluation-harness):

pip install lm-eval

# Evaluate GPT-4 on MMLU
lm_eval --model openai-chat --model_args model=gpt-4 --tasks mmlu --num_fewshot 5

For detailed benchmark testing patterns, see references/benchmarks.md and scripts/benchmark_runner.py.

Production Evaluation

Monitor and optimize LLM quality in production environments.

A/B Testing

Compare two LLM configurations:

• Variant A: GPT-4 (expensive, high quality)
• Variant B: Claude Sonnet (cheaper, fast)

Metrics:

• User satisfaction scores (thumbs up/down)
• Task completion rates
• Response time and latency
• Cost per successful interaction

Online Evaluation

Real-time quality monitoring:

• Response Quality: LLM-as-judge scoring every Nth response
• User Feedback: Explicit ratings, thumbs up/down
• Business Metrics: Conversion rates, support ticket resolution
• Cost Tracking: Tokens used, inference costs

Human-in-the-Loop

Sample-based human evaluation:

• Random Sampling: Evaluate 10% of responses
• Confidence-Based: Evaluate low-confidence outputs
• Error-Triggered: Flag suspicious responses for review

For production evaluation patterns and monitoring strategies, see references/production-evaluation.md.

Classification Task Evaluation

For tasks with discrete outputs (sentiment, intent, category).

Metrics:

• Accuracy: Correct predictions / Total predictions
• Precision: True positives / (True positives + False positives)
• Recall: True positives / (True positives + False negatives)
• F1 Score: Harmonic mean of precision and recall
• Confusion Matrix: Detailed breakdown of prediction errors

Quick Start (Python):

from sklearn.metrics import accuracy_score, precision_recall_fscore_support

y_true = ["positive", "negative", "neutral", "positive", "negative"]
y_pred = ["positive", "negative", "neutral", "neutral", "negative"]

accuracy = accuracy_score(y_true, y_pred)
precision, recall, f1, _ = precision_recall_fscore_support(y_true, y_pred, average='weighted')

print(f"Accuracy: {accuracy:.2f}")
print(f"Precision: {precision:.2f}")
print(f"Recall: {recall:.2f}")
print(f"F1 Score: {f1:.2f}")

For complete classification evaluation examples, see examples/python/classification_metrics.py.

Generation Task Evaluation

For open-ended text generation (summaries, creative writing, responses).

Automated Metrics (Use with Caution):

• BLEU: N-gram overlap with reference text (0-1 score)
• ROUGE: Recall-oriented overlap (ROUGE-1, ROUGE-L)
• METEOR: Semantic similarity with stemming
• BERTScore: Contextual embedding similarity (0-1 score)

Limitation: Automated metrics correlate weakly with human judgment for creative/subjective generation.

Recommended Approach:

1. Automated metrics: Fast feedback for objective aspects (length, format)
2. LLM-as-judge: Nuanced quality assessment (relevance, coherence, helpfulness)
3. Human evaluation: Final validation for subjective criteria (preference, creativity)

For detailed generation evaluation patterns, see references/evaluation-types.md.

Quick Reference Tables

Evaluation Framework Selection

Python Library Recommendations

Safety Evaluation Priority Matrix

Detailed References

For comprehensive documentation on specific topics:

• Evaluation types (classification, generation, QA, code): references/evaluation-types.md
• RAG evaluation deep dive (RAGAS framework): references/rag-evaluation.md
• Safety evaluation (hallucination, bias, toxicity): references/safety-evaluation.md
• Benchmark testing (MMLU, HumanEval, domain benchmarks): references/benchmarks.md
• LLM-as-judge best practices and prompts: references/llm-as-judge.md
• Production evaluation (A/B testing, monitoring): references/production-evaluation.md
• All metrics definitions and formulas: references/metrics-reference.md

Working Examples

Python Examples:

• examples/python/unit_evaluation.py - Basic prompt testing with pytest
• examples/python/ragas_example.py - RAGAS RAG evaluation
• examples/python/deepeval_example.py - DeepEval framework usage
• examples/python/llm_as_judge.py - GPT-4 as evaluator
• examples/python/classification_metrics.py - Accuracy, precision, recall
• examples/python/benchmark_testing.py - HumanEval example

TypeScript Examples:

• examples/typescript/unit-evaluation.ts - Vitest + OpenAI
• examples/typescript/llm-as-judge.ts - GPT-4 evaluation
• examples/typescript/langsmith-integration.ts - Production monitoring

Executable Scripts

Run evaluations without loading code into context (token-free):

• scripts/run_ragas_eval.py - Run RAGAS evaluation on dataset
• scripts/compare_models.py - A/B test two models
• scripts/benchmark_runner.py - Run MMLU/HumanEval benchmarks
• scripts/hallucination_checker.py - Detect hallucinations in outputs

Example usage:

# Run RAGAS evaluation on custom dataset
python scripts/run_ragas_eval.py --dataset data/qa_dataset.json --output results.json

# Compare GPT-4 vs Claude on benchmark
python scripts/compare_models.py --model-a gpt-4 --model-b claude-3-opus --tasks mmlu,humaneval

Integration with Other Skills

Related Skills:

• building-ai-chat: Evaluate AI chat applications (this skill tests what that skill builds)
• prompt-engineering: Test prompt quality and effectiveness
• testing-strategies: Apply testing pyramid to LLM evaluation (unit → integration → E2E)
• observability: Production monitoring and alerting for LLM quality
• building-ci-pipelines: Integrate LLM evaluation into CI/CD

Workflow Integration:

1. Write prompt (use prompt-engineering skill)
2. Unit test prompt (use llm-evaluation skill)
3. Build AI feature (use building-ai-chat skill)
4. Integration test RAG pipeline (use llm-evaluation skill)
5. Deploy to production (use deploying-applications skill)
6. Monitor quality (use llm-evaluation + observability skills)

Common Pitfalls

1. Over-reliance on Automated Metrics for Generation

• BLEU/ROUGE correlate weakly with human judgment for creative text
• Solution: Layer LLM-as-judge or human evaluation

2. Ignoring Faithfulness in RAG Systems

• Hallucinations are the #1 RAG failure mode
• Solution: Prioritize faithfulness metric (target > 0.8)

3. No Production Monitoring

• Models can degrade over time, prompts can break with updates
• Solution: Set up continuous evaluation (LangSmith, custom monitoring)

4. Biased LLM-as-Judge Evaluation

• Evaluator LLMs have biases (position bias, verbosity bias)
• Solution: Average multiple evaluations, use diverse evaluation prompts

5. Insufficient Benchmark Coverage

• Single benchmark doesn't capture full model capability
• Solution: Use 3-5 benchmarks across different domains

6. Missing Safety Evaluation

• Production LLMs can generate harmful content
• Solution: Add toxicity, bias, and hallucination checks to evaluation pipeline