LLM 평가 프레임워크 직접 구축 vs 기성 도구: 2026 팀별 선택 기준

# 유형 1: 결정론적(Deterministic) 지표 — 정규식·코드 일치
import json
 
def evaluate_json_output(response: str) -> bool:
    """모델이 유효한 JSON을 반환했는지 확인"""
    try:
        json.loads(response)
        return True
    except json.JSONDecodeError:
        return False

# 유형 2: 심사 기반(LLM-as-Judge) 지표
# 아래는 개념 설명용 의사코드입니다.
# 실제 구현 시 openai.chat.completions.create(...) 또는
# anthropic.messages.create(...)를 사용하세요.
def llm_judge_relevance(question: str, answer: str, judge_model) -> float:
    prompt = f"""
    질문: {question}
    답변: {answer}
    
    위 답변이 질문에 얼마나 관련성 있는지 0~1 사이 점수로만 반환하세요.
    """
    score = judge_model.complete(prompt)  # 실제 API 인터페이스로 교체 필요
    return float(score.strip())

# 유형 3: 통계적·참조 기반 지표 (ROUGE, BERTScore 등)
from rouge_score import rouge_scorer
 
def evaluate_with_rouge(reference: str, generated: str) -> dict:
    scorer = rouge_scorer.RougeScorer(['rouge1', 'rougeL'], use_stemmer=True)
    scores = scorer.score(reference, generated)
    return {
        'rouge1': scores['rouge1'].fmeasure,
        'rougeL': scores['rougeL'].fmeasure
    }

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_recall
from ragas.llms import LangchainLLMWrapper
from langchain_openai import ChatOpenAI
from datasets import Dataset
 
# RAGAS는 채점에 쓸 LLM 설정이 필요합니다 (2024년 이후 필수)
judge_llm = LangchainLLMWrapper(ChatOpenAI(model="gpt-4o"))
 
eval_data = {
    "question": [
        "우리 제품의 환불 정책은 어떻게 되나요?",
        "배송 기간은 얼마나 걸리나요?"
    ],
    "answer": [
        "구매 후 30일 이내에 환불 신청이 가능합니다.",
        "평균 3~5 영업일이 소요됩니다."
    ],
    "contexts": [
        ["환불은 구매일로부터 30일 이내 가능하며...", "교환은 7일 이내..."],
        ["일반 배송은 3~5 영업일, 특급 배송은 1~2 영업일..."]
    ],
    # context_recall 계산에는 ground_truth가 필수입니다.
    # faithfulness, answer_relevancy만 쓸 경우 이 필드는 생략 가능합니다.
    "ground_truth": [
        "30일 이내 환불 가능",
        "3~5 영업일 소요"
    ]
}
 
dataset = Dataset.from_dict(eval_data)
 
result = evaluate(
    dataset,
    metrics=[faithfulness, answer_relevancy, context_recall],
    llm=judge_llm
)
 
print(result)
# {'faithfulness': 0.92, 'answer_relevancy': 0.87, 'context_recall': 0.95}

# promptfooconfig.yaml
description: "고객 지원 챗봇 회귀 테스트"
 
prompts:
  - "당신은 친절한 고객 지원 담당자입니다. 다음 질문에 답하세요: {{question}}"
  - "고객 질문: {{question}}\n\n간결하고 정확하게 답변해 주세요."
 
providers:
  - openai:gpt-4o
  - anthropic:claude-3-5-sonnet-20241022
 
tests:
  - vars:
      question: "환불하고 싶어요"
    assert:
      - type: contains
        value: "환불"
      - type: llm-rubric
        value: "답변이 공감적이고 다음 단계를 안내하는가?"
      - type: not-contains
        value: "모르겠습니다"
 
  - vars:
      question: "배송이 너무 늦어요"
    assert:
      - type: llm-rubric
        value: "사과 표현이 포함되어 있는가?"
      - type: javascript
        # output은 모델의 응답 텍스트를 가리키는 Promptfoo 내장 변수입니다
        value: "output.length < 500"

# GitHub Actions에서 실행 (eval 먼저, 그 결과 기반으로 dataset 생성)
npx promptfoo eval --config promptfooconfig.yaml --output results.json
npx promptfoo generate dataset  # 결과 기반으로 추가 테스트 케이스 자동 생성

import asyncio
from dataclasses import dataclass
from typing import Callable, Any
from enum import Enum
 
class TestCategory(Enum):
    HAPPY_PATH = "happy_path"
    # 모델이 잘못된 시도 후 올바른 방향으로 스스로 수정하는 케이스
    # 예: "주문번호를 잘못 입력했다가 재시도해서 성공"
    RECOVERABLE = "recoverable"
    # 에러를 내야 하는 케이스 — cancel_order를 호출하지 않고 거절해야 함
    # 예: "이미 배송된 주문을 취소 시도 → 취소 불가 안내"
    UNRECOVERABLE = "unrecoverable"
    ADVERSARIAL = "adversarial"  # 적대적 입력
 
@dataclass
class EvalCase:
    name: str
    category: TestCategory
    input: dict
    expected_tool_calls: list[str]
    success_criteria: Callable[[Any], bool]
 
class AgentEvalHarness:
    def __init__(self, agent, cases: list[EvalCase]):
        self.agent = agent
        self.cases = cases
        self.results = []
 
    async def run(self) -> dict:
        for case in self.cases:
            result = await self._evaluate_case(case)
            self.results.append(result)
        return self._summarize()
 
    async def _evaluate_case(self, case: EvalCase) -> dict:
        # 에이전트가 (output, tool_calls) 튜플을 반환한다고 가정합니다.
        # 실제 에이전트 인터페이스에 따라 어댑터 레이어가 필요할 수 있습니다.
        actual_output, actual_tool_calls = await self.agent.run(case.input)
 
        return {
            "name": case.name,
            "category": case.category.value,
            "passed": case.success_criteria(actual_output),
            "tool_call_order_correct": actual_tool_calls == case.expected_tool_calls,
        }
 
    def _summarize(self) -> dict:
        by_category = {}
        for r in self.results:
            cat = r["category"]
            by_category.setdefault(cat, {"passed": 0, "total": 0})
            by_category[cat]["total"] += 1
            if r["passed"]:
                by_category[cat]["passed"] += 1
        return by_category
 
harness = AgentEvalHarness(agent=my_agent, cases=[
    EvalCase(
        name="주문 취소 정상 처리",
        category=TestCategory.HAPPY_PATH,
        input={"user_message": "주문 12345를 취소해주세요"},
        expected_tool_calls=["get_order", "cancel_order", "notify_user"],
        success_criteria=lambda out: "취소" in out and "확인" in out
    ),
    # 실제 프로덕션 버그에서 추가된 케이스
    EvalCase(
        name="이미 배송된 주문 취소 시도",
        category=TestCategory.UNRECOVERABLE,
        input={"user_message": "어제 배송된 주문 취소해주세요"},
        expected_tool_calls=["get_order"],  # cancel_order는 호출되면 안 됨
        success_criteria=lambda out: "취소 불가" in out or "배송 완료" in out
    ),
])