RAGAS 완전 가이드: RAG 시스템을 어떻게 정량적으로 평가하는가

RAG 파이프라인 전체:

[사용자 질문]
      ↓
[검색 단계] ← Context Precision, Context Recall로 평가
      ↓
[생성 단계] ← Faithfulness, Answer Relevancy로 평가
      ↓
[최종 답변]

질문: "제품의 배터리 수명은 얼마인가요?"
컨텍스트: "배터리는 최대 12시간 지속됩니다. 충전 시간은 2시간입니다."
답변: "배터리는 12시간이며, 방수 기능도 있습니다."

Claim 분석:
- "배터리는 12시간" → 컨텍스트에 지지됨 ✓
- "방수 기능도 있습니다" → 컨텍스트에 없음 ✗

Faithfulness = 1/2 = 0.5 (낮음! 할루시네이션 발생)

원래 질문: "배터리 수명이 얼마인가요?"
생성된 답변: "이 제품은 고급 재질로 만들어졌으며 다양한 색상이 있습니다."

Synthetic 질문 생성:
- "이 제품은 어떤 재질로 만들어졌나요?"
- "어떤 색상이 있나요?"

원래 질문과의 유사도: 매우 낮음
Answer Relevancy ≈ 0.1 (낮음! 답변이 질문을 무시함)

from ragas import evaluate
from ragas.metrics import (
    faithfulness,
    answer_relevancy,
    context_precision,
    context_recall,
)
from datasets import Dataset

# 평가 데이터셋 준비
# 각 샘플: question + 시스템이 생성한 answer + retrieved contexts + ground_truth
eval_data = {
    "question": [
        "제품의 배터리 수명은 얼마인가요?",
        "환불 정책은 어떻게 되나요?",
        "배송 기간은 얼마나 걸리나요?"
    ],
    "answer": [
        "배터리는 최대 12시간 지속됩니다.",
        "구매 후 30일 이내에 환불 신청이 가능합니다.",
        "일반 배송은 3-5 영업일이 소요됩니다."
    ],
    "contexts": [
        # 각 질문에 대해 검색된 컨텍스트 청크 목록
        [
            "배터리는 최대 12시간 지속됩니다. 충전 시간은 2시간입니다.",
            "제품 크기는 15cm x 10cm x 2cm입니다."
        ],
        [
            "고객은 구매 후 30일 이내에 환불을 신청할 수 있습니다.",
            "환불은 영업일 기준 5-7일 내에 처리됩니다."
        ],
        [
            "일반 배송: 3-5 영업일, 빠른 배송: 1-2 영업일",
            "배송비는 3만원 미만 주문 시 3,000원이 부과됩니다."
        ]
    ],
    "ground_truth": [
        "배터리 수명은 최대 12시간이며, 충전 시간은 2시간입니다.",
        "환불은 구매 후 30일 이내 신청 가능하고 5-7 영업일 내 처리됩니다.",
        "일반 배송은 3-5 영업일, 빠른 배송은 1-2 영업일이 소요됩니다."
    ]
}

dataset = Dataset.from_dict(eval_data)

# 평가 실행
results = evaluate(
    dataset,
    metrics=[
        faithfulness,
        answer_relevancy,
        context_precision,
        context_recall,
    ]
)

print(results)
# 출력 예시:
# {
#   'faithfulness': 0.95,
#   'answer_relevancy': 0.88,
#   'context_precision': 0.82,
#   'context_recall': 0.91
# }

# 결과를 DataFrame으로 변환해서 상세 분석
df = results.to_pandas()
print(df.to_string())

from ragas.llms import LangchainLLMWrapper
from langchain_openai import ChatOpenAI
from langchain_openai import OpenAIEmbeddings
from ragas.embeddings import LangchainEmbeddingsWrapper

# Judge LLM 설정 (비용 절감을 위해 GPT-4o-mini 사용 가능)
judge_llm = LangchainLLMWrapper(
    ChatOpenAI(model="gpt-4o-mini", temperature=0)
)

# 임베딩 설정 (Answer Relevancy 계산에 사용)
embeddings = LangchainEmbeddingsWrapper(OpenAIEmbeddings())

results = evaluate(
    dataset,
    metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
    llm=judge_llm,
    embeddings=embeddings,
)

# evaluate_rag.py - CI/CD에서 실행되는 평가 스크립트

import json
import sys
from datetime import datetime
from pathlib import Path
from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_precision, context_recall
from datasets import Dataset


def load_test_dataset(path: str) -> Dataset:
    """저장된 테스트 데이터셋 로드"""
    with open(path, 'r', encoding='utf-8') as f:
        data = json.load(f)
    return Dataset.from_dict(data)


def run_rag_on_testset(testset: Dataset, rag_chain) -> Dataset:
    """테스트셋의 각 질문을 RAG로 실행해서 answer와 contexts 수집"""
    answers = []
    contexts_list = []

    for question in testset["question"]:
        # RAG 실행
        result = rag_chain.invoke({"query": question})
        answers.append(result["result"])
        contexts_list.append([
            doc.page_content
            for doc in result["source_documents"]
        ])

    return testset.add_column("answer", answers).add_column("contexts", contexts_list)


def evaluate_and_gate(
    dataset: Dataset,
    thresholds: dict,
    save_path: str = None
) -> bool:
    """
    평가 실행 후 임계값 기반 통과/실패 판정.

    thresholds 예시:
    {
        "faithfulness": 0.8,
        "answer_relevancy": 0.75,
        "context_precision": 0.7,
        "context_recall": 0.75
    }
    """
    results = evaluate(
        dataset,
        metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
    )

    print("\n" + "="*50)
    print(f"RAG 평가 결과 - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print("="*50)

    all_passed = True
    for metric_name, threshold in thresholds.items():
        score = results[metric_name]
        passed = score >= threshold
        status = "PASS" if passed else "FAIL"
        print(f"{metric_name:25s}: {score:.3f} (임계값: {threshold}) [{status}]")
        if not passed:
            all_passed = False

    # 결과 저장 (히스토리 추적용)
    if save_path:
        result_data = {
            "timestamp": datetime.now().isoformat(),
            "scores": {k: float(v) for k, v in results.items()},
            "passed": all_passed
        }
        Path(save_path).parent.mkdir(parents=True, exist_ok=True)
        with open(save_path, 'a') as f:
            f.write(json.dumps(result_data) + "\n")

    return all_passed


# 실행
if __name__ == "__main__":
    # 테스트셋과 RAG 체인 로드
    testset = load_test_dataset("tests/rag_testset.json")
    # rag_chain = load_your_rag_chain()  # 실제 RAG 체인 로드

    # testset = run_rag_on_testset(testset, rag_chain)

    thresholds = {
        "faithfulness": 0.80,
        "answer_relevancy": 0.75,
        "context_precision": 0.70,
        "context_recall": 0.75,
    }

    passed = evaluate_and_gate(
        testset,
        thresholds=thresholds,
        save_path="results/rag_eval_history.jsonl"
    )

    sys.exit(0 if passed else 1)  # CI/CD에서 실패 시 빌드 중단

# .github/workflows/rag-evaluation.yml
name: RAG Quality Gate

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  evaluate-rag:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      - name: Install dependencies
        run: pip install ragas langchain openai datasets
      - name: Run RAG Evaluation
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: python evaluate_rag.py

from ragas.testset.generator import TestsetGenerator
from ragas.testset.evolutions import simple, reasoning, multi_context
from langchain_community.document_loaders import DirectoryLoader
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

# 문서 로드
loader = DirectoryLoader("./docs", glob="**/*.md")
documents = loader.load()

# 테스트셋 생성기 초기화
generator = TestsetGenerator.with_openai()

# 테스트셋 생성 (질문 유형 지정 가능)
testset = generator.generate_with_langchain_docs(
    documents,
    test_size=50,  # 총 50개 질문
    distributions={
        simple: 0.5,        # 단순 사실 질문 50%
        reasoning: 0.25,    # 추론 필요 질문 25%
        multi_context: 0.25 # 여러 문서 참조 필요 25%
    }
)

# 데이터셋을 파일로 저장
testset_df = testset.to_pandas()
testset_df.to_json("tests/rag_testset.json", orient='records', force_ascii=False)

print(f"생성된 질문 수: {len(testset_df)}")
print("\n샘플 질문:")
print(testset_df[['question', 'ground_truth']].head())

1. 기준선 측정 (RAGAS 실행)
      ↓
2. 가장 낮은 지표 확인
      ↓
3. 해당 지표 개선 (청킹/검색/프롬프트 수정)
      ↓
4. 다시 측정 → 개선 확인
      ↓
5. CI/CD에 Quality Gate 추가
      ↓
6. 코드 변경마다 자동 평가