OpenAI+LangChain RAG 할루시네이션 차단 전략

import { ChatOpenAI } from "@langchain/openai";
import { MemoryVectorStore } from "langchain/vectorstores/memory";
import { OpenAIEmbeddings } from "@langchain/openai";
import { RunnableSequence } from "@langchain/core/runnables";

const llm = new ChatOpenAI({
  model: "gpt-4.1-mini",
  temperature: 0,
});

const embeddings = new OpenAIEmbeddings({ model: "text-embedding-3-small" });
const vectorStore = await MemoryVectorStore.fromTexts(
  ["문서 내용 1", "문서 내용 2"],
  [{ id: 1 }, { id: 2 }],
  embeddings,
);

const retriever = vectorStore.asRetriever({ k: 4 });

const ragChain = RunnableSequence.from([
  {
    context: retriever,
    question: (input: { question: string }) => input.question,
  },
  async ({ context, question }) => {
    const prompt = `다음 컨텍스트를 기반으로 질문에 답변하세요.

컨텍스트:
${context.map((c: any) => c.pageContent).join("\n\n")}

질문: ${question}

규칙:
- 컨텍스트에 근거하지 않는 내용은 추측하지 마세요.
- 답변할 수 없으면 "제공된 문서만으로는 답할 수 없습니다"라고 말하세요.`;

    const res = await llm.invoke(prompt);
    return res;
  },
]);

const answer = await ragChain.invoke({ question: "질문 내용" });
console.log(answer.content);

당신은 사실 검증 어시스턴트입니다.

입력으로 다음 세 가지가 주어집니다.
1) 질문
2) 컨텍스트 문서들
3) 초안 답변

당신의 임무는 초안 답변의 각 문장이 컨텍스트에 의해 뒷받침되는지 확인하는 것입니다.

규칙:
- 컨텍스트에 명시적으로 존재하지 않는 정보는 "추측"으로 간주합니다.
- 파생 가능한 결론이라도, 컨텍스트에 근거가 명확하지 않으면 "불충분"으로 간주합니다.

출력 형식(JSON):
{
  "verdict": "ok" | "partial" | "reject",
  "issues": [
    {
      "sentence": "문장 내용",
      "reason": "왜 근거가 부족한지 설명",
      "severity": "low" | "medium" | "high"
    }
  ],
  "fixed_answer": "필요하다면 수정된 답변. reject인 경우에는 질문에 답하지 말고 '제공된 문서만으로는 답할 수 없습니다'라고 작성"
}

이제부터 위 형식의 JSON만 출력하세요.

import { z } from "zod";
import { ChatOpenAI } from "@langchain/openai";
import { StructuredOutputParser } from "langchain/output_parsers";

const groundingSchema = z.object({
  verdict: z.enum(["ok", "partial", "reject"]),
  issues: z
    .array(
      z.object({
        sentence: z.string(),
        reason: z.string(),
        severity: z.enum(["low", "medium", "high"]),
      }),
    )
    .optional(),
  fixed_answer: z.string(),
});

const groundingParser = new StructuredOutputParser(groundingSchema);

const groundingLlm = new ChatOpenAI({
  model: "gpt-4.1-mini",
  temperature: 0,
});

async function groundingCheck(args: {
  question: string;
  context: string;
  draftAnswer: string;
}) {
  const formatInstructions = groundingParser.getFormatInstructions();

  const prompt = `질문: ${args.question}

컨텍스트:
${args.context}

초안 답변:
${args.draftAnswer}

${formatInstructions}`;

  const res = await groundingLlm.invoke(prompt);
  const parsed = await groundingParser.parse(res.content as string);
  return parsed;
}

const ragWithGrounding = RunnableSequence.from([
  async (input: { question: string }) => {
    const docs = await retriever.getRelevantDocuments(input.question);
    const context = docs.map((d) => d.pageContent).join("\n\n");

    const draftPrompt = `다음 컨텍스트를 기반으로 질문에 답변하세요.

컨텍스트:
${context}

질문: ${input.question}

규칙:
- 컨텍스트에 없는 내용은 추측하지 마세요.
- 확실하지 않은 내용은 "제공된 문서만으로는 확실하지 않습니다"라고 말하세요.`;

    const draft = await llm.invoke(draftPrompt);

    const grounding = await groundingCheck({
      question: input.question,
      context,
      draftAnswer: draft.content as string,
    });

    return { grounding, context };
  },
  ({ grounding, context }) => {
    if (grounding.verdict === "reject") {
      return "제공된 문서만으로는 답할 수 없습니다.";
    }

    // partial인 경우 fixed_answer에 이미 수정된 답변이 들어있다고 가정
    return grounding.fixed_answer;
  },
]);

const safeAnswer = await ragWithGrounding.invoke({
  question: "질문 내용",
});

당신은 답변 검토 전문가입니다.

입력으로 질문과 답변이 주어집니다.

1) 질문에 직접적으로 답하고 있는지
2) 답변이 논리적으로 일관적인지
3) 중요한 전제나 예외 조건을 빠뜨리지 않았는지

를 검토한 뒤, 필요하면 답변을 수정하세요.

출력 형식(JSON):
{
  "is_good": boolean,
  "problems": ["문제점 1", "문제점 2"],
  "improved_answer": "개선된 답변 (수정이 필요 없으면 원본과 동일하게 유지)"
}

JSON만 출력하세요.

const selfCheckSchema = z.object({
  is_good: z.boolean(),
  problems: z.array(z.string()).optional(),
  improved_answer: z.string(),
});

const selfCheckParser = new StructuredOutputParser(selfCheckSchema);

const criticLlm = new ChatOpenAI({
  model: "gpt-4.1-mini",
  temperature: 0,
});

async function selfCheck(args: { question: string; answer: string }) {
  const formatInstructions = selfCheckParser.getFormatInstructions();
  const prompt = `질문: ${args.question}

답변:
${args.answer}

${formatInstructions}`;

  const res = await criticLlm.invoke(prompt);
  return selfCheckParser.parse(res.content as string);
}

const ragWithGroundingAndSelfCheck = RunnableSequence.from([
  async (input: { question: string }) => {
    const docs = await retriever.getRelevantDocuments(input.question);
    const context = docs.map((d) => d.pageContent).join("\n\n");

    const draftPrompt = `다음 컨텍스트를 기반으로 질문에 답변하세요.

컨텍스트:
${context}

질문: ${input.question}`;

    const draft = await llm.invoke(draftPrompt);

    const grounding = await groundingCheck({
      question: input.question,
      context,
      draftAnswer: draft.content as string,
    });

    if (grounding.verdict === "reject") {
      return {
        question: input.question,
        answer: "제공된 문서만으로는 답할 수 없습니다.",
      };
    }

    return {
      question: input.question,
      answer: grounding.fixed_answer,
    };
  },
  async ({ question, answer }) => {
    const check = await selfCheck({ question, answer });
    return check.improved_answer;
  },
]);

const finalAnswer = await ragWithGroundingAndSelfCheck.invoke({
  question: "질문 내용",
});