structverify 0.3.0__py3-none-any.whl

structverify/detection/synthetic_generator.py

@@ -0,0 +1,270 @@
+"""
+adaptation/synthetic_generator.py — 합성 학습 데이터 자동 생성
+
+변경 요약
+- positive claim 생성뿐 아니라
+  candidate detection용 negative / weak negative 샘플도 함께 생성
+- sentence_to_candidate 태스크 학습이 가능하도록 출력 구조 확장
+"""
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from structverify.utils.llm_client import LLMClient
+from structverify.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+CLAIM_GENERATION_PROMPT = """당신은 한국 뉴스 기자입니다.
+아래 공식 통계표 정보를 보고, 이 통계표로 검증할 수 있는 뉴스 주장 {n}개를 생성하세요.
+
+통계표 ID: {stat_id}
+통계표명: {stat_name}
+발행기관: {org_name}
+분류: {category_path}
+관련 키워드: {keywords}
+
+규칙:
+- 실제 뉴스에 나올법한 자연스러운 한국어 문장으로 작성
+- 반드시 구체적인 수치(%, 만명, 억원, ha 등)를 포함
+- 검증 가능한 사실 주장만 작성
+
+JSON 배열로 답하세요:
+[
+  {{
+    "claim": "뉴스에 나올법한 주장 문장",
+    "indicator": "핵심 지표명",
+    "claim_type": "increase|decrease|scale|comparison",
+    "expected_unit": "%, 만명, ha 등"
+  }}
+]
+"""
+
+NEGATIVE_CANDIDATE_PROMPT = """당신은 한국 뉴스 기자입니다.
+아래 통계표와 관련된 기사 문맥에서, "숫자가 있거나 기사 문장처럼 보이지만 공식 통계 검증 후보로는 부적절한 문장" {n}개를 생성하세요.
+
+통계표 ID: {stat_id}
+통계표명: {stat_name}
+발행기관: {org_name}
+분류: {category_path}
+관련 키워드: {keywords}
+
+규칙:
+- 뉴스 기사 문장처럼 자연스러운 한국어
+- 단순 일정 소개, 행사 설명, 발언 소개, 맥락 설명, 애매한 표현 등을 사용
+- 공식 통계와 바로 매핑하기 어렵게 작성
+- 일부 문장은 숫자를 포함해도 됨
+
+JSON 배열로 답하세요:
+[
+  {{
+    "claim": "검증 후보로는 부적절한 문장"
+  }}
+]
+"""
+
+SCHEMA_GENERATION_PROMPT = """아래 뉴스 주장에서 검증에 필요한 핵심 정보를 추출하세요.
+
+주장: "{claim}"
+관련 통계표: {stat_name} ({stat_id})
+
+JSON으로 답하세요:
+{{
+  "indicator": "측정 지표",
+  "time_period": "기준 시점",
+  "unit": "단위",
+  "population": "대상 범위",
+  "value": 수치 또는 null,
+  "stat_id": "{stat_id}"
+}}
+"""
+
+
+async def generate_synthetic_pairs(
+    catalog: list[dict[str, Any]],
+    llm: LLMClient,
+    claims_per_table: int = 3,
+    max_tables: int | None = None,
+) -> list[dict[str, Any]]:
+    tables = catalog[:max_tables] if max_tables else catalog
+    logger.info(f"합성 데이터 생성 시작: {len(tables)}개 통계표")
+
+    all_pairs: list[dict[str, Any]] = []
+
+    for idx, table in enumerate(tables):
+        try:
+            positive_claims = await _generate_claims(llm, table, claims_per_table)
+            negative_claims = await _generate_negative_candidates(llm, table, max(1, claims_per_table // 2))
+
+            # positive candidate
+            for claim_data in positive_claims:
+                claim_text = claim_data.get("claim", "").strip()
+                if not claim_text:
+                    continue
+
+                schema = await _generate_schema(llm, claim_data, table)
+                all_pairs.append({
+                    "task": "sentence_to_candidate",
+                    "claim": claim_text,
+                    "stat_id": table.get("stat_id", ""),
+                    "stat_name": table.get("stat_name", ""),
+                    "indicator": claim_data.get("indicator", ""),
+                    "claim_type": claim_data.get("claim_type", ""),
+                    "schema": schema,
+                    "candidate_label": True,
+                    "candidate_score": 0.95,
+                    "candidate_signals": {
+                        "source": "synthetic_positive",
+                        "verifiable_by_stat": True,
+                    },
+                    "source_table": table,
+                })
+
+            # negative candidate
+            for claim_data in negative_claims:
+                claim_text = claim_data.get("claim", "").strip()
+                if not claim_text:
+                    continue
+
+                all_pairs.append({
+                    "task": "sentence_to_candidate",
+                    "claim": claim_text,
+                    "stat_id": "",
+                    "stat_name": "",
+                    "indicator": "",
+                    "claim_type": "",
+                    "schema": {},
+                    "candidate_label": False,
+                    "candidate_score": 0.05,
+                    "candidate_signals": {
+                        "source": "synthetic_negative",
+                        "verifiable_by_stat": False,
+                    },
+                    "source_table": table,
+                })
+
+            if (idx + 1) % 50 == 0:
+                logger.info(f"진행: {idx + 1}/{len(tables)}")
+
+        except Exception as e:
+            logger.warning(f"통계표 {table.get('stat_id')} 처리 실패: {e}")
+
+    return _filter_quality(all_pairs)
+
+
+async def _generate_claims(
+    llm: LLMClient,
+    table: dict[str, Any],
+    n: int,
+) -> list[dict[str, Any]]:
+    prompt = CLAIM_GENERATION_PROMPT.format(
+        n=n,
+        stat_id=table.get("stat_id", ""),
+        stat_name=table.get("stat_name", ""),
+        org_name=table.get("org_name", ""),
+        category_path=table.get("category_path", ""),
+        keywords=", ".join(table.get("keywords", [])),
+    )
+    result = await llm.generate_json(
+        prompt=prompt,
+        system_prompt="한국 뉴스 기자. JSON 배열로만 답하세요.",
+    )
+    if isinstance(result, list):
+        return result
+    if isinstance(result, dict):
+        return [result]
+    return []
+
+
+async def _generate_negative_candidates(
+    llm: LLMClient,
+    table: dict[str, Any],
+    n: int,
+) -> list[dict[str, Any]]:
+    prompt = NEGATIVE_CANDIDATE_PROMPT.format(
+        n=n,
+        stat_id=table.get("stat_id", ""),
+        stat_name=table.get("stat_name", ""),
+        org_name=table.get("org_name", ""),
+        category_path=table.get("category_path", ""),
+        keywords=", ".join(table.get("keywords", [])),
+    )
+    result = await llm.generate_json(
+        prompt=prompt,
+        system_prompt="한국 뉴스 기자. JSON 배열로만 답하세요.",
+    )
+    if isinstance(result, list):
+        return result
+    if isinstance(result, dict):
+        return [result]
+    return []
+
+
+async def _generate_schema(
+    llm: LLMClient,
+    claim_data: dict[str, Any],
+    table: dict[str, Any],
+) -> dict[str, Any]:
+    prompt = SCHEMA_GENERATION_PROMPT.format(
+        claim=claim_data.get("claim", ""),
+        stat_name=table.get("stat_name", ""),
+        stat_id=table.get("stat_id", ""),
+    )
+    try:
+        return await llm.generate_json(
+            prompt=prompt,
+            system_prompt="통계 분석 전문가. JSON으로만 답하세요.",
+        )
+    except Exception:
+        return {}
+
+
+def _filter_quality(pairs: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """
+    품질 필터링
+
+    positive는 수치가 없어도 schema가 있으면 통과 가능
+    negative는 너무 짧은 문장만 제거
+    """
+    filtered: list[dict[str, Any]] = []
+    seen_claims: set[str] = set()
+    numeric_pattern = re.compile(r"\d")
+
+    for pair in pairs:
+        claim = pair.get("claim", "").strip()
+        if len(claim) < 8:
+            continue
+
+        if claim in seen_claims:
+            continue
+        seen_claims.add(claim)
+
+        is_positive = bool(pair.get("candidate_label", False))
+        if is_positive:
+            has_schema = bool(pair.get("schema"))
+            has_numeric = bool(numeric_pattern.search(claim))
+            if not has_schema and not has_numeric:
+                continue
+
+        filtered.append(pair)
+
+    return filtered
+
+
+async def save_synthetic_data(
+    pairs: list[dict[str, Any]],
+    output_path: str = "ml/data/synthetic_pretrain.jsonl",
+) -> None:
+    """
+    기존 저장 함수 그대로 써도 되지만, JSONL 저장은 유지한다.
+    """
+    import os
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, "w", encoding="utf-8") as f:
+        for item in pairs:
+            f.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+    logger.info(f"합성 데이터 저장 완료: {output_path} ({len(pairs)}건)")

structverify/explanation/_config.py

@@ -0,0 +1,18 @@
+"""[리팩] Step 9 설정 로드 — explanation/config.yaml (default.yaml 미수정)"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+_EXPLANATION_CONFIG_PATH = Path(__file__).parent / "config.yaml"
+
+
+def get_explanation_settings(config: dict | None) -> dict:
+    """explanation 설정 병합: config.yaml 기본값 ← config['explanation'] override."""
+    merged: dict = {}
+    if _EXPLANATION_CONFIG_PATH.is_file():
+        with open(_EXPLANATION_CONFIG_PATH, encoding="utf-8") as f:
+            merged.update(yaml.safe_load(f) or {})
+    merged.update((config or {}).get("explanation") or {})
+    return merged

structverify/explanation/_llm.py

@@ -0,0 +1,25 @@
+"""[리팩] explainer의 LLMClient 호출 → Step 9 전용 thin wrapper"""
+from __future__ import annotations
+
+from structverify.utils.llm_client import LLMClient
+
+from ._config import get_explanation_settings
+
+_EXPLANATION_SYSTEM_PROMPT = (
+    "팩트체크 전문 작가. 명확하고 간결한 한국어로 작성하세요."
+)
+
+
+async def generate_explanation_text(
+    prompt: str,
+    config: dict | None = None,
+) -> str:
+    """검증 설명용 LLM 텍스트 생성."""
+    expl_cfg = get_explanation_settings(config)
+    model_tier = expl_cfg.get("model_tier", "heavy")
+    llm = LLMClient(config=(config or {}).get("llm", {}))
+    return await llm.generate(
+        prompt=prompt,
+        system_prompt=_EXPLANATION_SYSTEM_PROMPT,
+        model_tier=model_tier,
+    )

structverify/explanation/explainer.py

@@ -0,0 +1,183 @@
+"""
+explanation/explainer.py — LLM 기반 설명 생성 + Provenance 렌더링 (Step 9)
+
+[김예슬 - 2026-04-22]
+- 기존 단일 프롬프트 → verdict 유형별 전용 프롬프트 3종으로 분리
+  · MATCH_PROMPT    : 일치 판정 — 어떤 통계가 근거인지 중심으로 설명
+  · MISMATCH_PROMPT : 불일치 판정 — 차이 수치, 원인 유형, 독자 주의 안내 포함
+  · UNVERIFIABLE_PROMPT : 검증 불가 — 왜 못 찾았는지, 다음 확인 방법 제시
+- mismatch_type별 원인 설명 문구 자동 생성 (_mismatch_reason_text)
+- _format_evidence(): Evidence 없을 때 안전하게 "N/A" 처리
+- _format_schema(): ClaimSchema 요약 텍스트 생성
+- generate_explanation() 반환값에 provenance_summary 자동 세팅
+
+[참고] ReAct (Yao et al., ICLR 2023)
+  Agent의 최종 Observation 단계에서 판정 근거를 자연어로 설명하는 Step 9
+
+[리팩 2026-06 / refactor/v1/js/explanation]
+- verdict별 프롬프트 문자열 → prompts/ 로 분리 (import만 유지, 동작 동일)
+- 수치·출처 포맷 헬퍼 → formatters.py 로 분리
+- LLM 실패 fallback 문구 → fallback.py 로 분리
+- LLM 호출 → _llm.py 로 분리
+- model_tier 등 모듈 설정 → explanation/config.yaml (default.yaml 미수정)
+"""
+from __future__ import annotations
+
+from structverify.core.schemas import (
+    Claim, VerdictType, VerificationResult,
+)
+# [리팩] explainer에 있던 포맷 헬퍼 → formatters.py (로직 동일)
+from .formatters import (
+    _calc_diff,
+    _calc_diff_pct,
+    _format_search_hint,
+    _format_stat_source,
+    _mismatch_reason_text,
+    _unverifiable_reason,
+)
+# [리팩] verdict별 LLM 프롬프트 문자열 → prompts/ (동작 변경 없음)
+from .prompts.match import MATCH_PROMPT
+from .prompts.mismatch import MISMATCH_PROMPT
+from .prompts.multihop import MULTIHOP_PROMPT
+from .prompts.unverifiable import UNVERIFIABLE_PROMPT
+# [리팩] LLM 실패 시 fallback 문구 → fallback.py (explainer에서 re-export)
+from .fallback import _fallback_explanation
+# [리팩] LLMClient 직접 호출 → _llm.py
+from ._llm import generate_explanation_text
+from structverify.graph.provenance import render_provenance_text
+from structverify.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+# ── 메인 함수 ─────────────────────────────────────────────────────────────
+
+async def generate_explanation(
+    claim: Claim,
+    result: VerificationResult,
+    config: dict | None = None,
+) -> str:
+    """
+    검증 결과에 대한 자연어 설명을 생성한다.
+
+    verdict 유형에 따라 다른 프롬프트를 사용:
+      MATCH        → MATCH_PROMPT (일치 근거 중심)
+      MISMATCH     → MISMATCH_PROMPT (차이 원인 + 독자 주의)
+      UNVERIFIABLE → UNVERIFIABLE_PROMPT (왜 못 찾았는지 + 직접 확인 방법)
+
+    Args:
+        claim: 검증 대상 주장
+        result: 검증 결과 (verdict, evidence, mismatch_type 포함)
+        config: 설정 dict
+
+    Returns:
+        자연어 설명 문자열
+    """
+    config = config or {}
+
+    # Provenance 텍스트 렌더링
+    prov_text = "출처 정보 없음"
+    if result.evidence and result.evidence.provenance:
+        prov_text = render_provenance_text(result.evidence.provenance)
+        result.provenance_summary = prov_text
+
+    prompt = _build_prompt(claim, result, prov_text)
+
+    try:
+        explanation = await generate_explanation_text(prompt, config)
+        logger.info(f"[Step 9] 설명 생성 완료: {claim.sent_id} ({result.verdict.value})")
+        return explanation
+
+    except Exception as e:
+        logger.error(f"설명 생성 실패: {e}")
+        # fallback — LLM 없이 기본 텍스트 생성
+        return _fallback_explanation(claim, result)
+
+
+# ── 내부 헬퍼 ─────────────────────────────────────────────────────────────
+
+def _build_prompt(
+    claim: Claim,
+    result: VerificationResult,
+    prov_text: str,
+) -> str:
+    """verdict 유형에 따라 적절한 프롬프트를 생성한다."""
+
+    ev = result.evidence
+    schema = claim.schema
+
+    claimed_value = schema.value if schema and schema.value is not None else "N/A"
+    unit = schema.unit or "" if schema else ""
+    official_value = ev.official_value if ev and ev.official_value is not None else "N/A"
+    stat_source = _format_stat_source(ev)
+
+    # [Multi-hop] 멀티홉으로 검증된 파생 주장은 전용 프롬프트
+    if getattr(result, "multihop_used", False) and result.multihop_detail:
+        d = result.multihop_detail
+        verdict_label = {
+            VerdictType.MATCH:        "✅ 일치 (MATCH)",
+            VerdictType.MISMATCH:     "❌ 불일치 (MISMATCH)",
+            VerdictType.UNVERIFIABLE: "❓ 검증 불가",
+        }.get(result.verdict, str(result.verdict))
+        return MULTIHOP_PROMPT.format(
+            verdict_label=verdict_label,
+            claim_text=claim.claim_text,
+            claimed_ratio=d.get("claimed_ratio", "N/A"),
+            computed_ratio=d.get("computed_ratio", "N/A"),
+            largest_value=f"{d.get('largest_value', 0):,.0f}",
+            smallest_value=f"{d.get('smallest_value', 0):,.0f}",
+            confidence=result.confidence,
+        )
+
+    if result.verdict == VerdictType.MATCH:
+        diff_pct = _calc_diff_pct(claimed_value, official_value)
+        # [수정] MATCH_PROMPT 템플릿이 쓰는 {indicator}/{claim_time}/
+        # {evidence_time} 플레이스홀더가 format 인자에서 누락돼 KeyError가
+        # 나던 버그 수정. claim.schema / evidence에서 값을 채운다.
+        _indicator = (schema.indicator if schema and schema.indicator
+                      else "지표")
+        _claim_time = (schema.time_period if schema and schema.time_period
+                       else "N/A")
+        _evidence_time = (ev.time_period if ev and ev.time_period
+                          else "N/A")
+        return MATCH_PROMPT.format(
+            claim_text=claim.claim_text,
+            claimed_value=claimed_value,
+            official_value=official_value,
+            unit=unit,
+            diff_pct=diff_pct,
+            confidence=result.confidence,
+            stat_source=stat_source,
+            provenance=prov_text,
+            indicator=_indicator,
+            claim_time=_claim_time,
+            evidence_time=_evidence_time,
+        )
+
+    elif result.verdict == VerdictType.MISMATCH:
+        diff_pct = _calc_diff_pct(claimed_value, official_value)
+        diff = _calc_diff(claimed_value, official_value)
+        mismatch_reason = _mismatch_reason_text(result.mismatch_type)
+        return MISMATCH_PROMPT.format(
+            claim_text=claim.claim_text,
+            claimed_value=claimed_value,
+            official_value=official_value,
+            unit=unit,
+            diff=diff,
+            diff_pct=diff_pct,
+            mismatch_reason=mismatch_reason,
+            confidence=result.confidence,
+            stat_source=stat_source,
+            provenance=prov_text,
+        )
+
+    else:  # UNVERIFIABLE
+        reason = _unverifiable_reason(claim, result)
+        search_hint = _format_search_hint(claim)
+        return UNVERIFIABLE_PROMPT.format(
+            claim_text=claim.claim_text,
+            reason=reason,
+            stat_source=stat_source,
+            search_hint=search_hint,
+        )
+

structverify/explanation/fallback.py

@@ -0,0 +1,29 @@
+"""[리팩] explainer._fallback_explanation 분리 — LLM 실패 시 기본 문구 생성"""
+from __future__ import annotations
+
+from structverify.core.schemas import Claim, VerdictType, VerificationResult
+
+
+def _fallback_explanation(claim: Claim, result: VerificationResult) -> str:
+    """LLM 실패 시 기본 텍스트로 fallback."""
+    verdict_kr = {
+        VerdictType.MATCH: "일치",
+        VerdictType.MISMATCH: "불일치",
+        VerdictType.UNVERIFIABLE: "검증 불가",
+    }.get(result.verdict, result.verdict.value)
+
+    base = f'"{claim.claim_text[:40]}..." — 판정: {verdict_kr}'
+
+    if result.verdict == VerdictType.MISMATCH and result.evidence:
+        ev = result.evidence
+        schema = claim.schema
+        if schema and schema.value and ev.official_value:
+            base += (
+                f" | 기사: {schema.value}{schema.unit or ''}"
+                f" / 공식: {ev.official_value}{ev.unit or ''}"
+            )
+
+    if result.provenance_summary:
+        base += f" | {result.provenance_summary}"
+
+    return base

structverify/explanation/formatters.py

@@ -0,0 +1,75 @@
+"""[리팩] explainer에 있던 수치·출처 포맷 헬퍼 분리 — _build_prompt에서 사용"""
+from __future__ import annotations
+
+from structverify.core.schemas import Claim, Evidence, MismatchType, VerificationResult
+
+
+def _mismatch_reason_text(mismatch_type: MismatchType | None) -> str:
+    """MismatchType을 독자가 이해할 수 있는 설명 문구로 변환한다."""
+    mapping = {
+        MismatchType.VALUE:       "단순 수치 오류 — 기사가 공식 수치와 다른 값을 인용",
+        MismatchType.TIME_PERIOD: "시점 불일치 — 다른 연도의 통계를 현재 수치처럼 인용",
+        MismatchType.POPULATION:  "대상 집단 불일치 — 다른 범위(전체 vs 일부)의 통계를 혼용",
+        MismatchType.EXAGGERATION:"과장/축소 — 실제 수치보다 크게 또는 작게 표현",
+    }
+    return mapping.get(mismatch_type, "수치 불일치")
+
+
+def _unverifiable_reason(claim: Claim, result: VerificationResult) -> str:
+    """검증 불가 이유를 구체적으로 서술한다."""
+    if result.evidence is None:
+        return "기준 데이터에서 관련 항목을 찾지 못함"
+    if result.evidence.official_value is None:
+        return "통계표는 찾았으나 해당 시점/대상의 수치가 없음"
+    if claim.schema is None or claim.schema.value is None:
+        return "기사에서 구체적인 수치를 추출하지 못함"
+    return "검증에 필요한 정보가 불충분함"
+
+
+def _format_stat_source(ev: Evidence | None) -> str:
+    """Evidence에서 통계 출처 텍스트를 생성한다."""
+    if not ev:
+        return "N/A"
+    parts = []
+    if ev.source_name:
+        parts.append(ev.source_name)
+    if ev.stat_table_id:
+        parts.append(f"표ID: {ev.stat_table_id}")
+    if ev.time_period:
+        parts.append(f"{ev.time_period} 기준")
+    return " | ".join(parts) if parts else "N/A"
+
+
+def _format_search_hint(claim: Claim) -> str:
+    """독자가 직접 검색할 수 있는 키워드를 제안한다."""
+    if not claim.schema:
+        return claim.claim_text[:30]
+    parts = []
+    if claim.schema.indicator:
+        parts.append(claim.schema.indicator)
+    if claim.schema.population:
+        parts.append(claim.schema.population)
+    if claim.schema.time_period:
+        parts.append(claim.schema.time_period)
+    return " ".join(parts) if parts else claim.claim_text[:30]
+
+
+def _calc_diff_pct(claimed: float | str, official: float | str) -> float:
+    """차이 비율(%) 계산. 수치가 없으면 0 반환."""
+    try:
+        c, o = float(claimed), float(official)
+        if o == 0:
+            return 0.0
+        return abs(c - o) / abs(o) * 100
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _calc_diff(claimed: float | str, official: float | str) -> str:
+    """실제 차이값 계산. 수치가 없으면 'N/A' 반환."""
+    try:
+        c, o = float(claimed), float(official)
+        diff = c - o
+        return f"{diff:+.1f}"
+    except (TypeError, ValueError):
+        return "N/A"

structverify/explanation/prompts/__init__.py

@@ -0,0 +1 @@
+# [리팩] verdict별 프롬프트 모듈 (explainer.py에서 분리)

structverify/explanation/prompts/match.py

@@ -0,0 +1,27 @@
+# [리팩] explainer.MATCH_PROMPT → prompts/match.py (문자열만 이동)
+MATCH_PROMPT = """당신은 팩트체크 전문 작가입니다.
+아래 검증 결과를 독자가 이해하기 쉽게 한국어로 설명하세요.
+
+[판정: ✅ 일치 (MATCH) — 이 판정은 확정입니다. 절대 "사실이 아니다"라고 쓰지 마세요.]
+주장: "{claim_text}"
+기사 수치: {claimed_value} {unit}
+공식 수치: {official_value} {unit}
+오차: {diff_pct:.1f}%
+신뢰도: {confidence:.0%}
+근거 통계: {stat_source}
+출처: {provenance}
+
+[작성 규칙]
+- 2~3문장으로 간결하게
+- 판정이 "일치"이므로 "사실입니다", "확인됩니다" 등 긍정적 표현 사용
+- "{{출처명}}에 따르면" 형식으로 출처 명시 (통계표/규정/기준 데이터 등)
+- 기사 수치와 공식 수치를 나란히 비교
+- 통계표 ID 포함
+- ⚠️ "사실이 아닙니다", "틀렸습니다" 등 부정 표현 절대 금지
+
+[⚠️ 주의 — 설명 전 반드시 확인]
+- 공식 통계 출처({stat_source})가 indicator({indicator})와 
+  *같은 국가/지역*의 통계인지 확인하세요.
+- 시점({claim_time} vs {evidence_time})이 다르면 
+  "같은 연도 데이터가 아님"을 반드시 명시하세요.
+"""

structverify/explanation/prompts/mismatch.py

@@ -0,0 +1,20 @@
+# [리팩] explainer.MISMATCH_PROMPT → prompts/mismatch.py
+MISMATCH_PROMPT = """당신은 팩트체크 전문 작가입니다.
+아래 검증 결과를 독자가 이해하기 쉽게 한국어로 설명하세요.
+
+[판정: 불일치 (MISMATCH) — 기사 수치와 공식 수치가 다릅니다.]
+주장: "{claim_text}"
+기사 수치: {claimed_value} {unit}
+공식 수치: {official_value} {unit}
+차이: {diff} {unit} ({diff_pct:.1f}%)
+불일치 유형: {mismatch_reason}
+신뢰도: {confidence:.0%}
+근거 통계: {stat_source}
+출처: {provenance}
+
+[작성 규칙]
+- 3~4문장으로 작성
+- 기사 수치({claimed_value})와 공식 수치({official_value})를 반드시 정확히 인용
+- 위에 적힌 수치만 사용하세요. 새로운 수치를 만들어내지 마세요.
+- 불일치 유형({mismatch_reason})에 맞는 원인 설명 포함
+- 출처 포함"""

structverify/explanation/prompts/multihop.py

@@ -0,0 +1,16 @@
+# [리팩] explainer.MULTIHOP_PROMPT → prompts/multihop.py
+MULTIHOP_PROMPT = """당신은 팩트체크 전문 작가입니다.
+아래 검증 결과를 독자가 이해하기 쉽게 한국어로 설명하세요.
+
+[판정: {verdict_label} — 멀티홉 검증으로 판정했습니다.]
+주장: "{claim_text}"
+주장한 비율/배수: {claimed_ratio}배
+계산된 비율/배수: {computed_ratio}배
+근거: 원천 수치 {largest_value} / {smallest_value} = {computed_ratio}배
+신뢰도: {confidence:.0%}
+
+[작성 규칙]
+- 이 주장은 기준 데이터에서 직접 찾을 수 없는 "파생 주장"(비율/배수)입니다
+- 대신 같은 지표의 원천 수치 2개를 기준 데이터에서 찾아 비율을 직접 계산했습니다
+- 2~3문장으로, 어떻게 계산했는지 설명: "원천 수치 {largest_value}와 {smallest_value}를 비교하면 약 {computed_ratio}배"
+- 위에 적힌 수치만 사용하세요. 새 수치를 만들지 마세요."""