RAG Evaluation: Metriken und Testing für KI-Systeme

pip install ragas langchain-openai langchain-community

from ragas import EvaluationDataset, SingleTurnSample, evaluate
from ragas.metrics import (
    Faithfulness,
    AnswerRelevancy,
    ContextPrecision,
    ContextRecall,
)
from ragas.llms import LangchainLLMWrapper
from ragas.embeddings import LangchainEmbeddingsWrapper
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
 
# Evaluator-LLM und Embeddings konfigurieren
evaluator_llm = LangchainLLMWrapper(
    ChatOpenAI(model="gpt-4o-mini", temperature=0)
)
evaluator_embeddings = LangchainEmbeddingsWrapper(
    OpenAIEmbeddings(model="text-embedding-3-small")
)
 
# Testdaten erstellen
samples = [
    SingleTurnSample(
        user_input="Was ist Retrieval-Augmented Generation?",
        retrieved_contexts=[
            "RAG kombiniert Informationsabruf mit Textgenerierung. "
            "Relevante Dokumente werden aus einer Wissensbasis abgerufen "
            "und dem LLM als Kontext übergeben.",
            "RAG wurde 2020 von Meta AI vorgestellt und hat sich "
            "als Standard für wissensbasierte KI-Systeme etabliert.",
        ],
        response=(
            "RAG (Retrieval-Augmented Generation) ist eine Technik, "
            "die Informationsabruf mit Textgenerierung kombiniert. "
            "Dabei werden relevante Dokumente aus einer Wissensbasis "
            "abgerufen und einem LLM als Kontext übergeben."
        ),
        reference=(
            "RAG kombiniert Dokumentenabruf mit LLM-Generierung, "
            "um Antworten auf Basis externer Wissensquellen zu liefern."
        ),
    ),
]
 
dataset = EvaluationDataset(samples=samples)
 
# Evaluation durchführen
results = evaluate(
    dataset=dataset,
    metrics=[
        Faithfulness(llm=evaluator_llm),
        AnswerRelevancy(llm=evaluator_llm, embeddings=evaluator_embeddings),
        ContextPrecision(llm=evaluator_llm),
        ContextRecall(llm=evaluator_llm),
    ],
)
 
# Ergebnisse anzeigen
df = results.to_pandas()
print(df[[
    "faithfulness",
    "answer_relevancy",
    "context_precision",
    "context_recall",
]])

from langchain_community.document_loaders import DirectoryLoader
from ragas.testset import TestsetGenerator
from ragas.llms import LangchainLLMWrapper
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from ragas.embeddings import LangchainEmbeddingsWrapper
 
# Dokumente laden
loader = DirectoryLoader("./knowledge_base/", glob="**/*.md")
docs = loader.load()
 
# Generator konfigurieren
generator_llm = LangchainLLMWrapper(
    ChatOpenAI(model="gpt-4o")
)
generator_embeddings = LangchainEmbeddingsWrapper(
    OpenAIEmbeddings(model="text-embedding-3-small")
)
 
generator = TestsetGenerator(
    llm=generator_llm,
    embedding_model=generator_embeddings,
)
 
# Testset aus Dokumenten generieren
testset = generator.generate_with_langchain_docs(
    documents=docs,
    testset_size=50,
)
 
# Als CSV exportieren für Versionierung
df = testset.to_pandas()
df.to_csv("tests/golden_dataset.csv", index=False)
print(f"{len(df)} Testfragen generiert")

pip install deepeval

# tests/test_rag_quality.py
import pytest
from deepeval import assert_test
from deepeval.test_case import LLMTestCase
from deepeval.metrics import (
    AnswerRelevancyMetric,
    FaithfulnessMetric,
    ContextualPrecisionMetric,
)
 
# Metriken mit Schwellenwerten definieren
faithfulness = FaithfulnessMetric(threshold=0.8)
relevancy = AnswerRelevancyMetric(threshold=0.7)
precision = ContextualPrecisionMetric(threshold=0.65)
 
# Testdaten
TEST_CASES = [
    {
        "input": "Was ist der Unterschied zwischen RAG und Fine-Tuning?",
        "expected": "RAG ruft externe Dokumente ab, Fine-Tuning passt Modellgewichte an.",
    },
    {
        "input": "Welche Metriken gibt es für RAG-Evaluation?",
        "expected": "Faithfulness, Answer Relevancy, Context Precision und Context Recall.",
    },
]
 
def get_rag_response(query: str) -> tuple[str, list[str]]:
    """Dein RAG-System aufrufen."""
    # Hier dein tatsächliches RAG-System einbinden
    from your_rag_system import query_rag
    result = query_rag(query)
    return result["answer"], result["source_chunks"]
 
 
@pytest.mark.parametrize("test_data", TEST_CASES)
def test_rag_pipeline(test_data):
    actual_output, retrieval_context = get_rag_response(test_data["input"])
 
    test_case = LLMTestCase(
        input=test_data["input"],
        actual_output=actual_output,
        retrieval_context=retrieval_context,
        expected_output=test_data["expected"],
    )
 
    assert_test(test_case, [faithfulness, relevancy, precision])

deepeval test run tests/test_rag_quality.py

# .github/workflows/rag-eval.yml
name: RAG Evaluation
 
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
 
jobs:
  evaluate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Python Setup
        uses: actions/setup-python@v5
        with:
          python-version: "3.12"
 
      - name: Install Dependencies
        run: pip install deepeval -r requirements.txt
 
      - name: RAG Evaluation
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: deepeval test run tests/test_rag_quality.py

[
  {
    "query": "Was ist der Unterschied zwischen RAG und Fine-Tuning?",
    "ground_truth": "RAG ruft externe Dokumente ab und nutzt sie als Kontext. Fine-Tuning passt die Modellgewichte an.",
    "relevant_doc_ids": ["doc_042", "doc_117"],
    "question_type": "comparison",
    "difficulty": "medium",
    "annotator": "domain_expert_1",
    "annotation_date": "2026-02-15"
  }
]

import json
from openai import AsyncOpenAI
 
client = AsyncOpenAI()
 
JUDGE_PROMPT = """Du bist ein Evaluierungsexperte für RAG-Systeme.
Bewerte die folgende Antwort auf einer Skala von 1-5.
 
Frage: {query}
Kontext: {context}
Antwort: {response}
 
Kriterien:
- Treue: Ist die Antwort durch den Kontext belegt?
- Relevanz: Beantwortet die Antwort die Frage?
- Vollständigkeit: Sind alle relevanten Informationen enthalten?
 
Antworte in JSON-Format:
{{"treue": <1-5>, "relevanz": <1-5>, "vollstaendigkeit": <1-5>, "begruendung": "<Text>"}}"""
 
 
async def llm_judge(query: str, context: str, response: str) -> dict:
    result = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "user",
            "content": JUDGE_PROMPT.format(
                query=query, context=context, response=response
            ),
        }],
        response_format={"type": "json_object"},
        temperature=0,
    )
    scores = json.loads(result.choices[0].message.content)
    return {
        "treue": scores["treue"] / 5.0,
        "relevanz": scores["relevanz"] / 5.0,
        "vollstaendigkeit": scores["vollstaendigkeit"] / 5.0,
        "begruendung": scores["begruendung"],
    }

# tests/conftest.py
import pytest
from deepeval.metrics import (
    FaithfulnessMetric,
    AnswerRelevancyMetric,
    ContextualPrecisionMetric,
)
 
# Quality Gates: Pipeline schlägt fehl wenn unterschritten
THRESHOLDS = {
    "faithfulness": 0.80,
    "relevancy": 0.70,
    "precision": 0.65,
}
 
@pytest.fixture(scope="session")
def rag_metrics():
    return [
        FaithfulnessMetric(threshold=THRESHOLDS["faithfulness"]),
        AnswerRelevancyMetric(threshold=THRESHOLDS["relevancy"]),
        ContextualPrecisionMetric(threshold=THRESHOLDS["precision"]),
    ]