Hallucination Detection & Correction

import os
from typing import Literal

from langchain.chat_models import init_chat_model
from pydantic import BaseModel, Field

judge = init_chat_model(os.environ["JUDGE_MODEL"], temperature=0)


class Claims(BaseModel):
    claims: list[str] = Field(description="Atomic factual claims made by the answer; skip greetings and hedges")


class Verdict(BaseModel):
    claim: str
    verdict: Literal["supported", "contradicted", "not_found"]
    evidence_chunk_id: str | None = None


class Verdicts(BaseModel):
    verdicts: list[Verdict]


extract = judge.with_structured_output(Claims)
check = judge.with_structured_output(Verdicts)


def faithfulness(answer: str, passages: str) -> tuple[float, list[Verdict]]:
    claims = extract.invoke("List the atomic factual claims in this answer:\n\n" + answer).claims
    if not claims:
        return 1.0, []
    verdicts = check.invoke(
        "For each claim, decide whether the passages support it, contradict it, or do not mention it. "
        "Use only the passages, not your own knowledge.\n\nPassages:\n" + passages
        + "\n\nClaims:\n" + "\n".join(f"- {c}" for c in claims)).verdicts
    supported = sum(v.verdict == "supported" for v in verdicts)
    return supported / len(claims), verdicts

from transformers import AutoModelForSequenceClassification

hhem = AutoModelForSequenceClassification.from_pretrained(
    "vectara/hallucination_evaluation_model", trust_remote_code=True)


def consistency(passages: str, sentences: list[str]) -> list[float]:
    """One score per answer sentence: close to 1 = supported by the passages, close to 0 = hallucinated."""
    return [float(s) for s in hhem.predict([(passages, sentence) for sentence in sentences])]

from typing import Literal

Action = Literal["send", "drop_unsupported", "regenerate", "retrieve_again", "abstain"]


def decide(score: float, verdicts: list[str], attempt: int, min_ok: float = 0.9, min_partial: float = 0.6) -> Action:
    """verdicts: 'supported' | 'contradicted' | 'not_found' for each claim."""
    if score >= min_ok:
        return "send"
    contradicted = verdicts.count("contradicted")
    not_found = verdicts.count("not_found")
    if attempt == 0 and not_found > contradicted:
        return "retrieve_again"
    if attempt == 0:
        return "regenerate"
    if score >= min_partial and contradicted == 0:
        return "drop_unsupported"
    return "abstain"

package com.example.docsassistant.rag.hallucination;

import java.util.List;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.evaluation.FactCheckingEvaluator;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.document.Document;
import org.springframework.ai.evaluation.EvaluationRequest;
import org.springframework.ai.evaluation.EvaluationResponse;
import org.springframework.ai.rag.advisor.RetrievalAugmentationAdvisor;
import org.springframework.stereotype.Service;

@Service
public class GroundedAnswerService {

    static final String ABSTAIN = "I could not find a reliable answer to this in the documentation.";

    private final ChatClient chatClient;
    private final FactCheckingEvaluator factChecker;

    public GroundedAnswerService(ChatClient docsChatClient, ChatClient.Builder judgeBuilder) {
        this.chatClient = docsChatClient;                          // has the RetrievalAugmentationAdvisor
        this.factChecker = FactCheckingEvaluator.builder(judgeBuilder).build();
    }

    public String ask(String question) {
        for (int attempt = 0; attempt < 2; attempt++) {
            String instruction = attempt == 0 ? question
                    : question + "\n\nAnswer strictly from the provided context. Omit anything it does not state.";
            ChatResponse response = chatClient.prompt().user(instruction).call().chatResponse();
            List<Document> context = response.getMetadata().get(RetrievalAugmentationAdvisor.DOCUMENT_CONTEXT);
            String answer = response.getResult().getOutput().getText();
            if (context == null || context.isEmpty()) {
                return ABSTAIN;
            }
            EvaluationResponse verdict = factChecker.evaluate(new EvaluationRequest(question, context, answer));
            if (verdict.isPass()) {
                return answer;
            }
        }
        return ABSTAIN;
    }
}

package com.example.docsassistant.l4j.hallucination;

import java.util.List;
import java.util.stream.Collectors;

import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.rag.content.Content;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import dev.langchain4j.service.V;

public final class FaithfulnessJudge {

    public enum Label { SUPPORTED, CONTRADICTED, NOT_FOUND }

    public record Verdict(String claim, Label label) {
    }

    public record Verdicts(List<Verdict> verdicts) {
        public double score() {
            return verdicts.isEmpty() ? 1.0
                    : verdicts.stream().filter(v -> v.label() == Label.SUPPORTED).count() / (double) verdicts.size();
        }
    }

    interface Judge {
        @SystemMessage("You check answers against passages. Use only the passages, never your own knowledge.")
        @UserMessage("""
                Split the answer into atomic factual claims and label each one SUPPORTED, CONTRADICTED or NOT_FOUND
                with respect to the passages.
                Passages:
                {{passages}}
                Answer:
                {{answer}}""")
        Verdicts judge(@V("passages") String passages, @V("answer") String answer);
    }

    private final Judge judge;

    public FaithfulnessJudge(ChatModel judgeModel) {
        this.judge = AiServices.create(Judge.class, judgeModel);
    }

    public Verdicts check(String answer, List<Content> sources) {
        String passages = sources.stream().map(c -> c.textSegment().text()).collect(Collectors.joining("\n\n"));
        return judge.judge(passages, answer);
    }
}