How to Build an LLM Evaluation Pipeline with DeepEval

Introduction to LLM Evaluation Pipelines

Large Language Models (LLMs) have transformed how developers build applications, but their non-deterministic nature makes them notoriously difficult to test. Traditional software testing relies on exact matches or predictable state changes, whereas LLM outputs can vary wildly while still being technically correct. This is where an LLM evaluation pipeline becomes essential.

DeepEval is an open-source evaluation framework specifically designed for LLM applications. It treats LLM evaluation like unit testing, allowing developers to programmatically assess the quality, relevance, and safety of model outputs. Building an evaluation pipeline with DeepEval matters because it enables continuous testing, prevents regressions when updating prompts or models, and provides a quantifiable way to measure hallucinations and answer quality before deploying to production.

Getting Started with DeepEval

To begin building your evaluation pipeline, you first need to install the DeepEval package and configure your environment. DeepEval uses "evaluator" LLMs (like GPT-4) to judge the outputs of your application LLM, so you will need an API key.

Install DeepEval via pip:

pip install deepeval

Next, set your OpenAI API key in your environment variables so DeepEval can use it for its evaluation metrics:

export OPENAI_API_KEY="your-api-key-here"

Building Your First Evaluation Pipeline

A standard DeepEval pipeline consists of three main components: the test case, the metrics, and the evaluation runner. Let's break down how to construct each part.

Defining Test Cases

In DeepEval, an LLMTestCase represents a single interaction with your LLM. It contains the input provided to the model, the actual output generated by the model, and optionally, the expected output and the context retrieved (if you are building a RAG application).

from deepeval.test_case import LLMTestCase

# Simulating an output from your LLM application
test_case = LLMTestCase(
    input="What is the capital of France?",
    actual_output="The capital of France is Paris.",
    expected_output="Paris.",
    retrieval_context=["France is a country in Europe. Its capital is Paris."]
)

Choosing Evaluation Metrics

DeepEval offers a variety of built-in metrics. For Retrieval-Augmented Generation (RAG) pipelines, two of the most critical metrics are Answer Relevancy (does the answer address the prompt?) and Faithfulness (is the answer factually grounded in the provided context, preventing hallucinations?).

from deepeval.metrics import AnswerRelevancyMetric, FaithfulnessMetric

# Initialize metrics with a passing threshold (0 to 1)
relevancy_metric = AnswerRelevancyMetric(threshold=0.5)
faithfulness_metric = FaithfulnessMetric(threshold=0.7)

Running the Evaluation

Once you have your test cases and metrics defined, you can run the evaluation using the evaluate function. This will prompt the evaluator LLM to analyze your test case against the metrics and output a score.

from deepeval import evaluate

# Run the evaluation
evaluate(
    test_cases=[test_case],
    metrics=[relevancy_metric, faithfulness_metric]
)

Advanced Pipeline Features

Creating Custom Metrics

While DeepEval provides robust out-of-the-box metrics, you may have specific business logic requirements. You can easily create custom metrics by subclassing the BaseMetric class. For example, you might want to ensure your LLM output never exceeds a certain character count.

from deepeval.metrics import BaseMetric
from deepeval.test_case import LLMTestCase

class LengthMetric(BaseMetric):
    def __init__(self, max_length: int = 50):
        self.max_length = max_length

    def measure(self, test_case: LLMTestCase):
        output_length = len(test_case.actual_output)
        self.success = output_length <= self.max_length
        self.score = 1.0 if self.success else 0.0
        self.reason = f"Output length is {output_length}, max allowed is {self.max_length}."

    def is_successful(self):
        return self.success

    @property
    def __name__(self):
        return "Length Constraint Metric"

Integration with Pytest for CI/CD

One of DeepEval's most powerful features is its seamless integration with Pytest. This allows you to incorporate LLM evaluation directly into your existing CI/CD pipelines, ensuring that no code changes degrade your LLM's performance before merging.

import pytest
from deepeval import assert_test
from deepeval.metrics import AnswerRelevancyMetric
from deepeval.test_case import LLMTestCase

def test_llm_output_relevancy():
    # 1. Define your test case
    test_case = LLMTestCase(
        input="How do I reset my password?",
        actual_output="Click on the 'Forgot Password' link on the login page."
    )
    
    # 2. Define your metric
    metric = AnswerRelevancyMetric(threshold=0.5)
    
    # 3. Assert the test passes
    assert_test(test_case, [metric])

You can run this test file exactly as you would a normal Python test: pytest test_llm.py. If the relevancy score falls below 0.5, the test will fail.

Best Practices for LLM Evaluation

Build a Golden Dataset: Curate a dataset of 50 to 100 high-quality input/output pairs that represent your application's core use cases. Use this dataset to run regression tests every time you change a prompt or swap models.
Combine Multiple Metrics: Do not rely on a single metric. An LLM might score high on Answer Relevancy but still hallucinate facts. Always pair relevancy with faithfulness or hallucination metrics.
Monitor Evaluation Costs: Because DeepEval uses LLMs to evaluate LLMs, running large datasets can become expensive. Use cheaper models (like GPT-3.5-turbo) for simple evaluations and reserve GPT-4 for complex reasoning metrics.
Set Realistic Thresholds: Start with lower thresholds (e.g., 0.5) and gradually increase them as your prompts and models improve. Setting the bar too high initially will result in flaky tests.

Conclusion

Building a robust LLM evaluation pipeline is no longer optional for production-grade AI applications. By leveraging DeepEval, developers can bridge the gap between traditional software testing and the unpredictable nature of generative AI. Through the use of structured test cases, comprehensive metrics, and Pytest integration, you can catch hallucinations, measure relevancy, and ensure your application maintains high quality throughout its lifecycle. Start small with a golden dataset, integrate the tests into your CI/CD workflow, and iterate on your thresholds to build reliable and trustworthy LLM applications.