Всем привет! Меня зовут Максим. Я NLP‑инженер в red_mad_robot и автор Telegram‑канала Максим Максимов // IT, AI. В этой статье я расскажу о том, как тестировать приложения с использованием Large Language Model (LLM), на примере инструмента DeepEval.

Тестирование приложений, в которых используются LLM, отличается от тестирования других приложений. В частности, можно выделить 2 основные проблемы:

Недетерминированность. В связи со своей спецификой LLM могут давать разные ответы на одни и те же запросы, что создаёт сложности во время тестирования;
Работа с естественным языком. LLM — это модели, которые принимают и генерируют текст. Соответственно, чтобы проводить тестирование, нужно каким‑то способом оценивать правильность текстового ответа LLM на определённый запрос.

Для решения этих проблем существуют подходы, которые оценивают семантику текста, а не точное равенство ожидаемого и полученного текста. Также для этого используют подход LLM‑as‑a‑judge. Это способ оценки, который использует LLM в качестве «судьи», производящего оценку ответов.

Для упрощения процесса тестирования LLM‑приложений был разработан DeepEval. Это инструмент, упрощающий тестирование таких приложений. Ниже мы рассмотрим базовые принципы и возможности данного инструмента, а также на практическом примере проведём оценку LLM‑приложения.

Что такое DeepEval

DeepEval — это простая в использовании платформа с открытым исходным кодом для оценки и тестирования систем, работающих на основе больших языковых моделей (LLM). Она похожа на Pytest, но специализируется на модульном тестировании выходных данных LLM. DeepEval предоставляет возможность для оценки результатов работы LLM на основе таких метрик, как G‑Eval, выполнение задач, релевантность ответов, токсичности и так далее. Для большинства метрик платформа применяет подход LLM‑as‑a‑judge (LLM в роли судьи).

Фреймворк может быть использован для оценки следующих систем:

Система	Описание
ИИ‑агенты	DeepEval позволяет оценивать работу AI‑агентов с точки зрения их ответов, рассуждений, использования инструментов и другое.
Чат‑боты	Помимо одношаговых сценариев (когда проверяется один ответ системы), DeepEval позволяет оценивать многошаговые диалоги. В частности, можно оценить способность чат‑бота поддерживать контекст на протяжении всего разговора, а не просто давать изолированные ответы на вопросы.
Retrieval‑Augmentation Generation (RAG)	DeepEval также поддерживает комплексную оценку RAG‑систем. Это включает: end‑to‑end тестирование общего качества, тестирование отдельных компонентов RAG (извлечение информации, генерация ответа и так далее), а также оценку многошаговых сценариев работы.
Model Context Protocol (MCP)	При работе с агентными системами часто требуется, чтобы агент умел использовать различные инструменты для взаимодействия со внешней средой, например, через MCP. DeepEval позволяет оценивать как одношаговые, так и многошаговые сценарии, в которых важна корректность вызовов этих инструментов.
LLM Arena	Также в DeepEval есть функционал для оценки и сравнения нескольких версий LLM‑приложения с целью выбора наилучшей. Например, можно сравнить качество работы при использовании разных LLM: gpt-4.1-mini, gpt-4o‑mini и других.

Основные концепции DeepEval

Далее рассмотрим некоторые концепции фреймворка DeepEval, на основе которых можно построить процесс тестирования LLM‑приложения.

Авторы DeepEval рекомендуют следующий подход к оценке LLM‑приложений с использованием их инструмента:

Подготовка датасета для тестирования;
Написание тест кейсов на Python;
Выбор метрик для оценивания;
Запуск тестов;
Нахождение краевых случаев для улучшения датасета;

От себя я бы здесь добавил нулевой шаг, где перед началом тестирования анализируется бизнес‑задача и бизнес‑цели системы, и уже на основе них делаются решения, что и по каким метрикам необходимо оценить.

Для тестирования работы LLM‑приложения с помощью DeepEval требуются следующие компоненты:

Датасет (набор примеров с правильными ответами);
Тестовые примеры;
Метрики;

Рассмотрим подробнее каждый из них.

Test Cases

Тестовый пример — это базовый, атомарный элемент для проверки LLM‑приложения, представляющий собой одно целевое взаимодействие с системой.

В DeepEval тестовые примеры могут быть трёх типов:

Одношаговые. Тестирование единичного запроса и ответа LLM‑приложения.
Многошаговые. Тестирование серии последовательных взаимодействий (диалога) с LLM.
Арена (Arena). Парное или групповое сравнение качества работы разных версий или конфигураций LLM‑приложения на одном наборе примеров.

Далее подробнее рассмотрим одношаговые и многошаговые примеры.

Одношаговые тестовые примеры

Синтаксис создания одношагового тестового примера выглядит следующим образом:

from deepeval.test_case import LLMTestCase

test_case = LLMTestCase(
    input="Почему небо голубое?",
    expected_output="Небо голубое из-за рэлеевского рассеяния, явления, при котором молекулы газов в атмосфере " \
                    "Земли сильнее рассеивают коротковолновый синий и фиолетовый свет Солнца, " \
                    "чем длинные волны (красный, желтый).",
    actual_output="Небо кажется голубым из-за явления, которое называется рэлеевское рассеяние.")

В данном случае, если мы хотим протестировать качество ответа LLM, LLMTestCase принимает 3 аргумента:

input — Входная текстовая строка в LLM‑приложение (обязательный параметр);
excpected_output — что ожидается на выходе;
actual_output — реальных выход.

Если бы было необходимо провести тестирование RAG, тестовый пример мог бы выглядеть следующим образом:

from deepeval.test_case import LLMTestCase


test_case = LLMTestCase(
    input="Какие есть акции на товары в январе?",    
    expected_output="В январе действуют акции на зимние товары: скидка 20% на все зимние куртки, " \
    "15% на утеплённые ботинки, " \
    "а также распродажа ёлочных украшений со скидкой до 50%.",
    actual_output="У нас сейчас скидки на зимние куртки 20% и на утеплённую обувь 15%.",
    retrieval_context=[
        "Актуальные акции января: "
        "1. Зимние куртки -20%. 2. Утеплённые ботинки -15%. 3. Ёлочные украшения -50%."
    ]
)

В данном случае, добавляется аргумент retrieval_context, в который помещаются найденный при работе RAG контекст.

Многошаговые тестовые примеры

Помимо одношаговых тестовых примеров, DeepEval дает возможность производить оценку серии взаимодействий с LLM‑приложением. Это может быть актуально, например, для чат‑ботов, которым необходим держать контекст на протяжении всего диалога.

Для создания тестового сценария необходим диалог пользователя и системы. Вот как выглядит реализация простого многошагово тестового примера:

from deepeval.test_case import Turn, ConversationalTestCase

turns = [
    Turn(role="user", content="Сколько стоит литр молока?"),
    Turn(role="assistant", content="Какой жирности Вам требуется молоко?"),
    Turn(role="user", content="3.2 %"),
    Turn(role="assistant", content="Стоимость 1 литра молока жирностью 3.2 % равна 100 руб."),
]

test_case = ConversationalTestCase(turns=turns)

В зависимости от сценария работы и метрики, в многошаговые тестовые примеры могут передаваться следующие параметры:

scenario — описываются обстоятельства, в которых происходит диалог;
expected_outcome — ожидаемые результат для данного сценария (scenario);
chatbot_role — роль, которую должен играть чат‑бот;
user_description — описания пользователя для конкретной беседы;
context — контекст, который получает LLM‑приложения в качестве источников информации.

Пример:

from deepeval.test_case import Turn, ConversationalTestCase

test_case = ConversationalTestCase(
    scenario="Пользователь разочарован сервисом и требует вернуть деньги",
    expected_outcome="AI перенаправляет запрос реальному оператору.",
    turns=[Turn(...), Turn(...)])

Более подробную информацию про одношаговые тестовые примеры можно найти в документации здесь, а также про многошаговые тестовые примеры можно прочитать здесь.

Datasets

Датасет представляет собой набор данных, который содержит так называемые «золотые данные» (или эталонные данные), которые в дальнейшем будут использоваться для создания тестовых примеров:

Пустой датасет может быть создан следующим образом

from deepeval.dataset import EvaluationDataset

dataset = EvaluationDataset()

Датасет может содержать только один вид данных: одношаговые или многошаговые. Это определяется при добавлении «золотых данных». Распишем процесс создания «золотых данных» и тестовых примеры по ним.

Сначала в датасет добавляются эталонные данные

from deepeval.dataset import EvaluationDataset, Golden
dataset = EvaluationDataset(
                            goldens=[Golden(input="Какое твое имя?"),
                                    Golden(input="Что по новостям?")])

Также по необходимости примеры могут добавляться после инициализации датасета

# ...
dataset.add_golden(Golden(input="Как дела?"))

Далее на основе датасета происходит создание тестовых примеров для тестирования приложения

from deepeval.test_case import LLMTestCase
...

for golden in dataset.goldens:
    test_case = LLMTestCase(
        input=golden.input,
        actual_output=your_llm_app(golden.input) # результат выполнения LLM-приложения
    )
    dataset.add_test_case(test_case)

Таким образом готовятся данные и тестовые примеры, которые будут оцениваться по определенным метрикам.

Eval Metrics

DeepEval предоставляет более 50 готовых к использованию метрик оценки. С их помощью происходит оценка работы приложения на основе созданных тестовых примеров (о которых говорилось выше).

Практически все метрики в DeepEval используют подход LLM‑as‑a‑judge и выдают оценку в диапазоне от 0 до 1. Метрика считается успешной только в том случае, если она равна или больше threshold (аргумент, который устанавливается при инициализации метрики). По умолчанию threshold равен 0.5.

DeepEval включает следующие виды метрик:

Custom metrics. Позволяют определять собственные критерии, используя подход LLM‑as‑a‑judge;
RAG. Метрики для оценки релевантности ответа при генерации, качество нахождения контекста и другое (как в RAGAS);
Агенты. Оценка результата выполнения задачи, правильность вызовов инструментов, соблюдения плана и другое;
Многошаговые. В диалоговых системах может оцениваться соблюдение роли ассистентом, точность достижения цели, использование инструментов и другое;
MCP. Оценка использования MCP в одношаговых и многошаговых сценариях, а также завершения задач;
Безопасность. Оценка предвзятости, токсичности, утечки персональных данных и другое;
Изображения. DeepEval позволяет работать с изображениями и оценивать качество работы системы с изображениями (например, оценка преобразования текста в изображения);
Другие. DeepEval позволяет оценивать галлюцинации LLM, суммаризация текста. Также возможна реализация своих кастомных метрик.

Для большинства метрик требуются 1–2 параметра (у Test Cases), поэтому необходимо ознакомится с выбранной метрикой, чтобы узнать какие параметры необходимы. Это можно сделать в документации здесь или здесь.

Рассмотрим пример расчета релевантности ответа для прошлого примера, используя DeepEval

from deepeval import evaluate
from deepeval.test_case import LLMTestCase
from deepeval.metrics import AnswerRelevancyMetric

metric = AnswerRelevancyMetric(
    threshold=0.7,
    model="gpt-4.1"
)

test_case = LLMTestCase(
    input="Почему небо голубое?",
    actual_output="Небо кажется голубым из-за явления, которое называется рэлеевское рассеяние.",
)

# Единичный запуск метрики
metric.measure(test_case)
print(metric.score)

Для AnswerRelevancyMetric можно задать порог (threshold) и модель, которая будет выступать в роли судьи (LLM‑as‑a‑judge). Подробнее можно посмотреть здесь.

Также интересным способом оценки является создание метрик с собственными критериями для тестового случая. Рассмотрим пример такой оценки на основе подхода G‑Eval.

G‑Eval — это метод, который использует LLM‑as‑a‑judge в сочетании с цепочкой рассуждений (CoT, Chain‑of‑Thought) для оценки результатов LLM‑приложения в соответствии с произвольными пользовательскими критериями.

from deepeval.metrics import GEval
from deepeval.test_case import LLMTestCase, LLMTestCaseParams

politeness_metric = GEval(
    name="Вежливость",
    criteria="Определить, насколько ответ вежливый и учтивый по шкале от 0 до 1.",
    evaluation_steps=[
        "Проверить наличие приветствия или вежливого обращения",
        "Оценить общий тон ответа",
        "Отметить, содержит ли ответ благодарность или доброжелательные пожелания"
    ],
    evaluation_params=[LLMTestCaseParams.INPUT, LLMTestCaseParams.ACTUAL_OUTPUT],
    model="gpt-4.1"
)

test_case = LLMTestCase(
    input="Мой заказ №12345 ещё не прибыл. Что происходит?",
    actual_output="Задержка доставки. Ждите.",
    expected_output="Здравствуйте! К сожалению, ваш заказ №12345 задерживается. Мы уже связались с курьерской службой и уточняем сроки. Приносим извинения за неудобства!"
)

politeness_metric.measure(test_case)
print(f"Оценка вежливости: {politeness_metric.score}")
print(f"Обоснование: {politeness_metric.reason}")

Можем заметить, что в аргумент criteria для G‑eval мы могли передать собственный критерий оценки на естественном языке.

Оценка LLM-приложения

Собрав воедино вышеперечисленные компоненты, можно использовать разработанные тестовые сценарии для оценки работы LLM‑приложения. В DeepEval возможна как комплексная оценка приложения (или End-2-End оценка), а также оценка на уровне компонентов.

Рассмотрим пример с e2e оценкой приложения.

Комплексная оценка LLM-приложения с DeepEval — Комплексная оценка LLM‑приложения с DeepEval

В данном случае, система рассматривается как «черный ящик», которому на вход подаётся запрос, а на выходе оценивается результат её работы.

Как и описывалось выше, необходимо определить метрику оценки, создать Golden (эталонные) данные, тестовые примеры. Далее происходит полная оценка и выдача результата тестирования.

Рассмотрим простой пример

# Установка: pip install -U deepeval
# Файл test_llm_app.py
from your_agent import your_llm_app # заменить на ваше LLM приложение
from deepeval.dataset import EvaluationDataset, Golden
from deepeval.metrics import AnswerRelevancyMetric
from deepeval import evaluate

# инициализация метрики
metric = AnswerRelevancyMetric(model=”...”)

# Создание датасета
dataset = EvaluationDataset()

# Добавление Golden данных
dataset.add_golden(Golden(input="..."))
…..
dataset.add_golden(Golden(input="..."))

# Создание тестовых примеров
test_cases = []

for golden in dataset.goldens:
    res, text_chunks = your_llm_app(golden.input)
    test_case = LLMTestCase(input=golden.input, actual_output=res, retrieval_context=text_chunks)
    test_cases.append(test_case)

# Запуск оценки
evaluate(
    test_cases=test_cases,
    metrics=[AnswerRelevancyMetric()]
)

Далее можно запустить тестирование в консоли:

python test_llm_app.py

Пример тестирования LLM-приложения с DeepEval

Теперь опробуем данный инструмент на практическом примере. Создадим простого AI‑ассистента с RAG, а далее напишем логику его тестирования с помощью DeepEval.

Ниже будет описан процесс создания простого ассистента с RAG, если желаете перейти сразу к тестированию, кликайте сюда.

Создание тестового ассистента с RAG

Для создания базы знаний я воспользовался DeepSeek. Сначала сгенерировал 60 товаров с описанием и поместил их в текстовый документ.

Далее написал Python код для создания чанков (1 чанк — 1 продукт).

import re
import os

def split_products_to_chunks(input_file_path, output_dir="chunks"):
    """
    Разделяет текстовый файл с товарами на чанки (один товар = один чанк)
    
    Args:
        input_file_path (str): Путь к исходному текстовому файлу с товарами
        output_dir (str): Директория для сохранения чанков
    """
    
    # Читаем исходный файл
    with open(input_file_path, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # Регулярное выражение для поиска товаров
    # Ищем номер товара с точкой в начале строки
    product_pattern = r'\n\d+\.\s[^\n]+(?:\n(?!\d+\.)[^\n]*)*'
    
    # Находим все товары
    products = re.findall(product_pattern, '\n' + content)  # Добавляем \n в начало для корректной работы
    return products

# Путь к вашему текстовому файлу с товарами
input_file = "products.txt" 
# Создаем чанки
products = split_products_to_chunks(input_file)

Далее создадим векторную базу данных. В качестве инструмента для векторизации воспользуюсь sentence_transformers и моделью deepvk/USER‑base (для русского языка). В качестве векторной базы данных возьму FAISS.

from sentence_transformers import SentenceTransformer
import faiss

# векторизация товаров
model = SentenceTransformer("deepvk/USER‑base")
embeddings = model.encode(products)
d = embeddings[0].shape[0]
print(d) # 768

# сохранение векторов в векторную базу данных
index = faiss.IndexFlatL2(d)
index.add(embeddings)
# количество объектов в векторной базе данных
print(index.ntotal) # 60

# реализуем функцию поиска по запросу
def retrieve(query: str, top_k: int=3):
    embedding = model.encode([query])

    _, I = index.search(embedding, top_k)  # search
    searched_product = [products[i] for i in I[0]]
    return searched_product

Проверим работу на простом примере

searched_product = retrieve("Освежающий гель с экстрактом морских водорослей")
print(*searched_product)

Отлично, теперь добавим функционал генерации ответа по найденному контексту. В качестве LLM воспользуюсь моделью с OpenRouter google/gemini-2.5-flash‑lite‑preview-09-2025.

import os

from openai import OpenAI

client = OpenAI(
  base_url=os.getenv("OPENAI_BASE_URL"),
  api_key=("OPENAI_API_KEY"),
)

model = "google/gemini-2.5-flash-lite-preview-09-2025"

system_prompt = "Сгенерируй ответ на вопрос на основе контекста."

user_prompt = "Вопрос: {query}. Контекст: {context}. Ответ:"

def generate_answer(query, context):
    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt.format(query=query, context=context)}
        ]
    )
    
    return response.choices[0].message.content

Теперь соберем все в единый pipeline, в котором подается на вход запрос пользователя, происходит поиск контекста, и далее на основе контекста генерируется ответ.

def rag_pipeline(query):
    # ищем релевантный контекст
    context = retrieve(query)
    # генерируем ответ на основе контекста
    answer = generate_answer(query, context)
    return answer

Создание тестов для ассистента с DeepEval

Далее напишем несколько автотестов для нашего ассистента, используя DeepEval.

В качестве примера создадим несколько тестов для оценки релевантности (Answer Relevancy). Эта метрика оценивает, насколько релевантен actual_output (ответ от LLM‑приложения) входным данным input.

Так как в метрике AnswerRelevancyMetric используется подход LLM‑as‑a‑judge, для оценки требуется LLM.

В DeepEval возможно использования встроенных моделей из Ollama, Azure OpenAI, Anthropic, Gemini и др., а также можно использовать свою кастомную модель. В данном примере мы осуществим работу со своей моделью.

Для этого необходимо создать класс‑наследник от базового класса DeepEvalBaseLLM с методами __init__, load_model, a_generate, generate, get_model_name. Затем следует инициализировать метрику AnswerRelevancyMetric, передав ей эту модель в аргументы. В качестве LLM я взял google/gemini-2.5-flash‑lite‑preview-09-2025.

Вот как это выглядит на Python

# Создан файл test_rag.py
import os

from deepeval.models.base_model import DeepEvalBaseLLM
from deepeval.metrics import AnswerRelevancyMetric

from dotenv import load_end

load_env()

# Кастомный класс LLM
class CustomOpenAIModel(DeepEvalBaseLLM):
    def __init__(self, model_name: str, base_url: str, api_key: str):
        self.model_name = model_name
        self.client = OpenAI(
            base_url=base_url,
            api_key=api_key
        )

    def load_model(self):
        return self.client

    def generate(self, prompt: str) -> str:
        client = self.load_model()
        response = client.chat.completions.create(
            model=self.model_name,
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content

    async def a_generate(self, prompt: str) -> str:
        return self.generate(prompt)

    def get_model_name(self):
        return self.model_name

# Инициализация модели
custom_model = CustomOpenAIModel(
    model_name=os.getenv("OPENAI_DEFAULT_MODEL"),
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY", "")
)

# Инициализация метрики
metric = AnswerRelevancyMetric(
    model=custom_model
)

Далее добавим 3 тестовых запроса

rag_requests = ["Я хочу купить ароматическую свечу. Что можешь посоветовать?",
                "У вас есть оливковое масло?? Срочно!!!",
                "У вас есть молоток?"]

Создадим набор данных и заполним его нашими запросами

from deepeval.dataset import EvaluationDataset, Golden

dataset = EvaluationDataset()

# создание тестовый набор
for request in rag_requests:
    dataset.add_golden(
        Golden(
            input=request
        )
    )

Из них создадим тестовые примеры, используя созданный выше RAG pipeline

from deepeval.test_case import LLMTestCase

# создаем тестовые примеры
for golden in dataset.goldens:
    test_case = LLMTestCase(
        input=golden.input,
        actual_output=rag_pipeline(golden.input)
    )
    dataset.add_test_case(test_case)

Для запуска тестов из Python кода воспользуемся функцией evaluate.

from deepeval import evaluate

evaluate(test_cases=dataset.test_cases, metrics=[metric])

Весь код выглядит следующим образом

Скрытый текст

import os

from openai import OpenAI

from deepeval.models.base_model import DeepEvalBaseLLM
from deepeval.test_case import LLMTestCase
from deepeval.dataset import EvaluationDataset, Golden
from deepeval.metrics import AnswerRelevancyMetric
from deepeval import evaluate

from rag_app import rag_pipeline

class CustomOpenAIModel(DeepEvalBaseLLM):
    def __init__(self, model_name: str, base_url: str, api_key: str):
        self.model_name = model_name
        self.client = OpenAI(
            base_url=base_url,
            api_key=api_key
        )


    def load_model(self):
        return self.client


    def generate(self, prompt: str) -> str:
        client = self.load_model()
        response = client.chat.completions.create(
            model=self.model_name,
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content


    async def a_generate(self, prompt: str) -> str:
        return self.generate(prompt)


    def get_model_name(self):
        return self.model_name

# Инициализация модели
custom_model = CustomOpenAIModel(
    model_name=os.getenv("OPENAI_DEFAULT_MODEL"),
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY", "")
)

rag_requests = ["Я хочу купить ароматическую свечу. Что можешь посоветовать?",
                "У вас есть оливковое масло?? Срочно!!!",
                "У вас есть молоток?"]

metric = AnswerRelevancyMetric(
    model=custom_model
)

dataset = EvaluationDataset()

# создание тестовый набор
for request in rag_requests:
    dataset.add_golden(
        Golden(
            input=request
        )
    )    

# создаем тестовые примеры
for golden in dataset.goldens:
    test_case = LLMTestCase(
        input=golden.input,
        actual_output=rag_pipeline(golden.input)
    )
    dataset.add_test_case(test_case)

evaluate(test_cases=dataset.test_cases, metrics=[metric])

Запустим созданные тесты командой в терминале:

python test_rag.py

В консоли будут выведены результаты запуска тестов

В конце пишется итоговая метрика по всем тестам

Заключение

В этой статье были разобраны базовые концепции библиотеки DeepEval, а также приведен практический пример использования этого инструмента в реальном проекте. Данная информация не является исчерпывающей. DeepEval содержит еще много интересного функционала, который доступен в официальной документации. Обязательно изучите ее!

Подписывайтесь на мой Telegram‑канал, в котором я также рассказываю интересные вещи об IT и AI технологиях.

Тестирование LLM-приложений с DeepEval