Upload 19 files

scripts/chunk_handlers.py

@@ -39,6 +39,51 @@ def format_hotel_header(hotel_name: str, hotel_name_ko: Optional[str], chain: st
     return content
 
 
+def format_evidence(evidence_list: list, max_items: int = 2, max_quote_len: int = 80) -> str:
+    """Evidence 배열을 청크에 포함할 포맷으로 변환
+    
+    Args:
+        evidence_list: evidence 객체 리스트
+        max_items: 포함할 최대 evidence 수
+        max_quote_len: 인용문 최대 길이
+    
+    Returns:
+        포맷된 출처 정보 문자열 (비어있으면 빈 문자열)
+    """
+    if not evidence_list or not isinstance(evidence_list, list):
+        return ""
+    
+    content = "\n출처:\n"
+    added = 0
+    
+    for ev in evidence_list:
+        if added >= max_items:
+            break
+        if not isinstance(ev, dict):
+            continue
+        
+        section = ev.get("section_path", "")
+        quote = ev.get("quote", "")
+        
+        if section or quote:
+            if section:
+                content += f"  - [{section}] "
+            else:
+                content += "  - "
+            
+            if quote:
+                # 인용문 길이 제한
+                truncated = quote[:max_quote_len]
+                if len(quote) > max_quote_len:
+                    truncated += "..."
+                content += f'"{truncated}"\n'
+            else:
+                content += "\n"
+            added += 1
+    
+    return content if added > 0 else ""
+
+
 # ===========================================================================
 # 핸들러: 로열티 프로그램
 # ===========================================================================
@@ -90,7 +135,10 @@ def handle_membership_tiers(data: Any, context: Dict[str, Any]) -> List[Dict[str
     """membership_tiers 처리"""
     chunks = []
     chain = context.get("chain", "UNKNOWN")
-    
+
+    if data is None:
+        return chunks
+
     tiers = data if isinstance(data, list) else [data]
     
     for tier in tiers[:10]:
@@ -101,29 +149,77 @@ def handle_membership_tiers(data: Any, context: Dict[str, Any]) -> List[Dict[str
         tier_level = tier.get("tier_level", "N/A")
         tier_chain = tier.get("chain", chain)
         
-        upgrade_req = tier.get("upgrade_requirement", {})
-        req_nights = upgrade_req.get("nights", "N/A")
-        req_points = upgrade_req.get("points")
+        # 스키마 필드명: qualification (TierQualification)
+        # 하위 호환성: upgrade_requirement도 폴백 지원
+        qualification = tier.get("qualification", tier.get("upgrade_requirement", {}))
+        req_nights = qualification.get("nights_required", qualification.get("nights", "N/A"))
+        req_stays = qualification.get("stays_required")
+        req_points = qualification.get("points_required", qualification.get("points"))
+        req_spending = qualification.get("spending_required")
+        qual_period = qualification.get("qualification_period", "calendar_year")
+        
+        # 스키마 필드명: bonus_points_percentage
+        bonus_pct = tier.get("bonus_points_percentage", tier.get("elite_bonus_points"))
         
         content = f"""
 등급: {tier_name} ({tier_level})
 체인: {tier_chain}
 등급 순위: {tier.get("rank", "N/A")}
 자격 요건:
-  - 숙박: {req_nights}박
-  - 포인트: {req_points if req_points else 'N/A'}
-보너스 포인트: {tier.get("elite_bonus_points", "N/A")}
-"""
+  - 숙박: {req_nights}박"""
+        
+        if req_stays:
+            content += f"\n  - 체류: {req_stays}회"
+        if req_points:
+            content += f"\n  - 포인트: {req_points:,}P" if isinstance(req_points, int) else f"\n  - 포인트: {req_points}"
+        if req_spending and isinstance(req_spending, dict):
+            content += f"\n  - 지출: {req_spending.get('amount', 'N/A')} {req_spending.get('currency', '')}"
+        
+        content += f"\n  - 산정 기간: {qual_period}\n"
+        
+        # 대체 자격 경로
+        alt_paths = qualification.get("alternative_paths", [])
+        if alt_paths:
+            content += f"  - 대체 경로: {', '.join(alt_paths[:3])}\n"
+        
+        if bonus_pct:
+            content += f"보너스 포인트: {bonus_pct}%\n"
+        
+        # 등급 유지 조건: retention (TierRetention)
+        retention = tier.get("retention")
+        if retention and isinstance(retention, dict):
+            content += "\n등급 유지 조건:\n"
+            ret_nights = retention.get("nights_required")
+            ret_points = retention.get("points_required")
+            if ret_nights:
+                content += f"  - 숙박: {ret_nights}박\n"
+            if ret_points:
+                content += f"  - 포인트: {ret_points:,}P\n"
+        
+        # 평생 등급
+        if tier.get("lifetime_tier_available"):
+            content += f"\n평생 등급: 가능"
+            if tier.get("lifetime_requirements"):
+                content += f" ({tier.get('lifetime_requirements')})"
+            content += "\n"
         
         # 주요 혜택
         benefits = tier.get("benefits", [])
         if benefits:
-            content += "주요 혜택:\n"
+            content += "\n주요 혜택:\n"
             for benefit in benefits[:8]:
                 if isinstance(benefit, dict):
                     ben_name = benefit.get("name", benefit.get("benefit_name", "N/A"))
-                    ben_desc = benefit.get("description", "")[:100]
-                    content += f"- {ben_name}: {ben_desc}\n"
+                    ben_desc = benefit.get("description", "")[:80]
+                    content += f"  - {ben_name}"
+                    if ben_desc:
+                        content += f": {ben_desc}"
+                    content += "\n"
+        
+        # evidence 정보 포함 (선택적)
+        evidence = tier.get("evidence", [])
+        if evidence:
+            content += format_evidence(evidence, max_items=2)
         
         chunks.append({
             "content": content.strip(),
@@ -138,6 +234,147 @@ def handle_membership_tiers(data: Any, context: Dict[str, Any]) -> List[Dict[str
     return chunks
 
 
+# ===========================================================================
+# 핸들러: 마일스톤 프로그램
+# ===========================================================================
+
+def handle_milestone_programs(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """milestone_program 처리 (IHG Milestone Rewards 등)"""
+    chunks = []
+    chain = context.get("chain", "UNKNOWN")
+    
+    programs = data if isinstance(data, list) else [data]
+    
+    for program in programs[:3]:
+        if not isinstance(program, dict):
+            continue
+        
+        program_name = program.get("program_name", "Milestone Rewards")
+        program_chain = program.get("chain", chain)
+        minimum_tier = program.get("minimum_tier", "N/A")
+        reset_period = program.get("reset_period", "calendar_year")
+        
+        content = f"""
+마일스톤 프로그램: {program_name}
+체인: {program_chain}
+참여 최소 등급: {minimum_tier}
+리셋 주기: {reset_period}
+롤오버 가능: {"예" if program.get("rollover_enabled") else "아니오"}
+"""
+        
+        # 롤오버 가능 등급
+        rollover_tiers = program.get("rollover_eligible_tiers", [])
+        if rollover_tiers:
+            content += f"롤오버 가능 등급: {', '.join(str(t) for t in rollover_tiers)}\n"
+        
+        # 마일스톤 목록
+        milestones = program.get("milestones", [])
+        if milestones:
+            content += "\n마일스톤 보상:\n"
+            for milestone in milestones[:10]:
+                if not isinstance(milestone, dict):
+                    continue
+                    
+                nights = milestone.get("nights_required", "?")
+                is_bonus = milestone.get("is_bonus_choice", False)
+                max_sel = milestone.get("max_selections", 1)
+                
+                content += f"\n  [{nights}박 달성]"
+                if is_bonus:
+                    content += f" (Bonus Choice - {max_sel}개 선택)"
+                content += ":\n"
+                
+                # 보상 옵션
+                options = milestone.get("reward_options", [])
+                for opt in options[:6]:
+                    if isinstance(opt, dict):
+                        opt_name = opt.get("name", "N/A")
+                        bonus_pts = opt.get("bonus_points")
+                        quantity = opt.get("quantity")
+                        
+                        opt_str = f"    - {opt_name}"
+                        if bonus_pts:
+                            opt_str += f" ({bonus_pts:,}P)"
+                        elif quantity:
+                            opt_str += f" ({quantity}개)"
+                        content += opt_str + "\n"
+        
+        content += DISCLAIMER_SHORT
+        
+        chunks.append({
+            "content": content.strip(),
+            "metadata": {
+                "type": "milestone_program",
+                "program_name": program_name,
+                "chain": program_chain,
+                "minimum_tier": str(minimum_tier)
+            }
+        })
+    
+    return chunks
+
+
+# ===========================================================================
+# 핸들러: 파트너 등급 매칭
+# ===========================================================================
+
+def handle_partner_status_matches(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """partner_status_matches 처리 (파트너 등급 매칭)"""
+    chunks = []
+    chain = context.get("chain", "UNKNOWN")
+    
+    matches = data if isinstance(data, list) else [data]
+    
+    # 여러 파트너를 하나의 청크로 묶기
+    if not matches:
+        return chunks
+    
+    content = f"""
+파트너 등급 매칭 프로그램
+체인: {chain}
+
+"""
+    
+    for match in matches[:10]:
+        if not isinstance(match, dict):
+            continue
+        
+        partner_name = match.get("partner_name", "N/A")
+        partner_program = match.get("partner_program", "")
+        partner_tier = match.get("partner_tier", "N/A")
+        required_tier = match.get("required_hotel_tier", "N/A")
+        validity = match.get("validity", "")
+        
+        content += f"• {partner_name}"
+        if partner_program:
+            content += f" ({partner_program})"
+        content += f"\n"
+        content += f"  - 필요 호텔 등급: {required_tier}\n"
+        content += f"  - 부여 파트너 등급: {partner_tier}\n"
+        
+        if validity:
+            content += f"  - 유효 기간: {validity}\n"
+        
+        # 파트너 혜택
+        partner_benefits = match.get("partner_benefits", [])
+        if partner_benefits:
+            content += f"  - 혜택: {', '.join(partner_benefits[:3])}\n"
+        
+        content += "\n"
+    
+    content += DISCLAIMER_SHORT
+    
+    chunks.append({
+        "content": content.strip(),
+        "metadata": {
+            "type": "partner_status_match",
+            "chain": chain
+        }
+    })
+    
+    return chunks
+
+
 # ===========================================================================
 # 핸들러: 포인트 시스템
 # ===========================================================================
@@ -162,24 +399,88 @@ def handle_points_systems(data: Any, context: Dict[str, Any]) -> List[Dict[str,
             content = f"""
 포인트 시스템: {point_name}
 체인: {system.get("chain", chain)}
-
-적립 규칙:
 """
 
+            # 스키마 필드명: expiration_policy (PointExpirationPolicy)
+            # 하위 호환성: expiry도 폴백 지원
+            expiration = system.get("expiration_policy", system.get("expiry"))
+            if expiration:
+                if isinstance(expiration, dict):
+                    expires = expiration.get("expires", expiration.get("has_expiry", True))
+                    exp_months = expiration.get("expiration_months", expiration.get("expiry_period"))
+                    can_extend = expiration.get("can_extend_with_activity", False)
+                    activity_types = expiration.get("activity_types", [])
+                    
+                    content += f"\n만료: {'있음' if expires else '없음'}"
+                    if exp_months:
+                        content += f" ({exp_months}개월)"
+                    content += "\n"
+                    
+                    if can_extend:
+                        content += f"활동으로 연장: 가능"
+                        if activity_types:
+                            content += f" ({', '.join(activity_types)})"
+                        content += "\n"
+                else:
+                    content += f"\n만료: {expiration}\n"
+
             # 적립 규칙
+            content += "\n적립 규칙:\n"
             earning_rules = system.get("earning_rules", [])
             if earning_rules and isinstance(earning_rules, list):
                 for rule in earning_rules[:6]:
                     if isinstance(rule, dict):
-                        content += f"- {rule.get('name', 'N/A')}: {rule.get('rate', 'N/A')}\n"
+                        rule_name = rule.get("rule_name", rule.get("name", "N/A"))
+                        category = rule.get("category", "")
+                        points_per_unit = rule.get("points_per_unit")
+                        spending_unit = rule.get("spending_unit", {})
+                        
+                        content += f"  - {rule_name}"
+                        if category:
+                            content += f" ({category})"
+                        content += ": "
+                        
+                        # 스키마: points_per_unit, spending_unit (Money 객체)
+                        if points_per_unit and spending_unit:
+                            # spending_unit이 dict인 경우 Money 구조 확인
+                            if isinstance(spending_unit, dict):
+                                unit_amount = spending_unit.get("amount", "N/A")
+                                unit_currency = spending_unit.get("currency", "")
+                                if unit_amount != "N/A" and unit_currency:
+                                    content += f"{unit_amount} {unit_currency}당 {points_per_unit}P"
+                                else:
+                                    content += f"{points_per_unit}P"
+                            else:
+                                # spending_unit이 단순 값인 경우 (하위 호환성)
+                                content += f"{spending_unit}당 {points_per_unit}P"
+                        elif rule.get("rate"):
+                            content += f"{rule.get('rate')}"
+                        else:
+                            content += "N/A"
+                        content += "\n"
+                        
+                        # 한도
+                        monthly_cap = rule.get("monthly_cap")
+                        yearly_cap = rule.get("yearly_cap")
+                        if monthly_cap:
+                            content += f"    월 한도: {monthly_cap:,}P\n"
+                        if yearly_cap:
+                            content += f"    연 한도: {yearly_cap:,}P\n"
+
+            # 사용 규칙
+            redemption_rules = system.get("redemption_rules", [])
+            if redemption_rules:
+                content += "\n사용 규칙:\n"
+                for rule in redemption_rules[:3]:
+                    if isinstance(rule, dict):
+                        r_type = rule.get("redemption_type", "N/A")
+                        min_points = rule.get("minimum_points", "N/A")
+                        content += f"  - {r_type}: 최소 {min_points:,}P\n" if isinstance(min_points, int) else f"  - {r_type}: 최소 {min_points}P\n"
 
-            # 만료
-            expiry = system.get("expiry")
-            if expiry:
-                if isinstance(expiry, dict):
-                    content += f"\n만료: {expiry.get('has_expiry', '있음')} ({expiry.get('expiry_period', 'N/A')})"
-                else:
-                    content += f"\n만료: {expiry}"
+            # 전환 파트너
+            transfer_partners = system.get("transfer_partners", [])
+            if transfer_partners:
+                content += f"\n전환 파트너: {', '.join(transfer_partners[:5])}\n"
 
             chunks.append({
                 "content": content.strip(),
@@ -254,12 +555,69 @@ def handle_hotel_properties(data: Any, context: Dict[str, Any]) -> List[Dict[str
     return chunks
 
 
+# ===========================================================================
+# 핸들러: 호텔 브랜드
+# ===========================================================================
+
+def handle_hotel_brands(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """hotel_brands 처리"""
+    chunks = []
+    chain = context.get("chain", "UNKNOWN")
+    
+    brands = data if isinstance(data, list) else [data]
+    
+    for brand in brands[:10]:
+        if not isinstance(brand, dict):
+            continue
+        
+        brand_code = brand.get("brand_code", "N/A")
+        brand_name = brand.get("brand_name", "N/A")
+        brand_chain = brand.get("chain", chain)
+        tier = brand.get("tier", "N/A")
+        
+        # 한국어 이름
+        name_localized = brand.get("brand_name_localized", {})
+        name_ko = name_localized.get("ko") if isinstance(name_localized, dict) else None
+        
+        content = f"""
+호텔 브랜드: {brand_name}
+"""
+        if name_ko and name_ko != brand_name:
+            content += f"브랜드명 (한국어): {name_ko}\n"
+        
+        content += f"""브랜드 코드: {brand_code}
+체인: {brand_chain}
+티어: {tier}
+"""
+        
+        # 기본 혜택
+        default_benefits = brand.get("default_benefits", [])
+        if default_benefits:
+            content += "\n브랜드 기본 혜택:\n"
+            for benefit in default_benefits[:5]:
+                if isinstance(benefit, dict):
+                    ben_name = benefit.get("name", "N/A")
+                    content += f"  - {ben_name}\n"
+        
+        chunks.append({
+            "content": content.strip(),
+            "metadata": {
+                "type": "hotel_brand",
+                "brand_code": brand_code,
+                "brand_name": brand_name,
+                "tier": str(tier)
+            }
+        })
+    
+    return chunks
+
+
 # ===========================================================================
 # 핸들러: 등급별 구현
 # ===========================================================================
 
 def handle_tier_implementations(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """tier_implementations 처리"""
+    """tier_implementations 처리 - 국가/호텔명 정보 포함으로 검색 정확도 향상"""
     chunks = []
     chain = context.get("chain", "UNKNOWN")
     
@@ -273,10 +631,28 @@ def handle_tier_implementations(data: Any, context: Dict[str, Any]) -> List[Dict
         tier_level = impl.get("tier_level", "N/A")
         impl_chain = impl.get("chain", chain)
         
+        # extra_attributes에서 국가/호텔명 추출 (검색 정확도 향상)
+        extra = impl.get("extra_attributes", {})
+        country = extra.get("country", "")
+        hotel_name = extra.get("hotel_name", "")
+        region = extra.get("region", "")
+        
         content = f"""
 호텔별 멤버십 혜택 구현
-호텔: {hotel_id}
-체인: {impl_chain}
+"""
+        # 실제 호텔명이 있으면 우선 표시
+        if hotel_name:
+            content += f"호텔: {hotel_name}\n"
+        else:
+            content += f"호텔 ID: {hotel_id}\n"
+        
+        # 국가/지역 정보 (검색 매칭에 중요)
+        if country:
+            content += f"국가: {country}\n"
+        if region:
+            content += f"지역: {region}\n"
+            
+        content += f"""체인: {impl_chain}
 등급: {tier_level}
 라운지 이용: {'가능' if impl.get('lounge_access') else '불가'}
 조식 포함: {'포함' if impl.get('breakfast_included') else '미포함'}
@@ -290,16 +666,28 @@ def handle_tier_implementations(data: Any, context: Dict[str, Any]) -> List[Dict
         for override in overrides[:5]:
             if isinstance(override, dict):
                 category = override.get("benefit_category", "N/A")
-                detail = override.get("implementation_detail", "")[:100]
+                detail = override.get("implementation_detail", "")[:150]
                 content += f"- {category}: {detail}\n"
+                
+                # 팁 추가
+                tips = override.get("tips", [])
+                for tip in tips[:2]:
+                    content += f"  → {tip}\n"
+        
+        # 메타데이터에도 국가 정보 포함
+        metadata = {
+            "type": "tier_implementation",
+            "hotel_id": hotel_id,
+            "tier_level": tier_level
+        }
+        if country:
+            metadata["country"] = country
+        if hotel_name:
+            metadata["hotel_name"] = hotel_name
         
         chunks.append({
             "content": content.strip(),
-            "metadata": {
-                "type": "tier_implementation",
-                "hotel_id": hotel_id,
-                "tier_level": tier_level
-            }
+            "metadata": metadata
         })
     
     return chunks
@@ -326,9 +714,29 @@ def handle_credit_cards(data: Any, context: Dict[str, Any]) -> List[Dict[str, An
         issuer = card.get("issuer", "N/A")
         issuer_code = card.get("issuer_code", "")
         
+        # 스키마 구조: AnnualFee.total (Money 객체)
+        # 하위 호환성: 레거시 annual_fee.amount도 지원
         annual_fee = card.get("annual_fee", {})
-        fee_amount = annual_fee.get("amount", "N/A") if isinstance(annual_fee, dict) else annual_fee
-        fee_currency = annual_fee.get("currency", "KRW") if isinstance(annual_fee, dict) else ""
+        if isinstance(annual_fee, dict):
+            # 스키마 구조: annual_fee.total.amount
+            total_fee = annual_fee.get("total", annual_fee)  # 폴백: 직접 접근
+            if isinstance(total_fee, dict):
+                fee_amount = total_fee.get("amount", "N/A")
+                fee_currency = total_fee.get("currency", "KRW")
+            else:
+                fee_amount = annual_fee.get("amount", "N/A")
+                fee_currency = annual_fee.get("currency", "KRW")
+            
+            # 상세 연회비 정보
+            base_fee = annual_fee.get("base_fee", {})
+            partner_fee = annual_fee.get("partner_fee", {})
+            family_fee = annual_fee.get("family_card_fee", {})
+            waiver_conds = annual_fee.get("waiver_conditions", [])
+        else:
+            fee_amount = annual_fee
+            fee_currency = "KRW"
+            base_fee = partner_fee = family_fee = {}
+            waiver_conds = []
         
         content = f"""
 신용카드: {card_name}
@@ -336,7 +744,22 @@ def handle_credit_cards(data: Any, context: Dict[str, Any]) -> List[Dict[str, An
         
         if issuer_code:
             content += f" ({issuer_code})"
-        content += f"\n연회비: {fee_amount:,} {fee_currency}\n" if isinstance(fee_amount, (int, float)) else f"\n연회비: {fee_amount} {fee_currency}\n"
+        
+        # 연회비 표시
+        if isinstance(fee_amount, (int, float)):
+            content += f"\n연회비: {fee_amount:,} {fee_currency}\n"
+        else:
+            content += f"\n연회비: {fee_amount} {fee_currency}\n"
+        
+        # 상세 연회비 (스키마 구조 반영)
+        if base_fee and isinstance(base_fee, dict) and base_fee.get("amount"):
+            content += f"  - 기본: {base_fee.get('amount'):,} {base_fee.get('currency', '')}\n"
+        if partner_fee and isinstance(partner_fee, dict) and partner_fee.get("amount"):
+            content += f"  - 제휴: {partner_fee.get('amount'):,} {partner_fee.get('currency', '')}\n"
+        if family_fee and isinstance(family_fee, dict) and family_fee.get("amount"):
+            content += f"  - 가족카드: {family_fee.get('amount'):,} {family_fee.get('currency', '')}\n"
+        if waiver_conds:
+            content += f"  - 면제 조건: {', '.join(waiver_conds[:2])}\n"
         
         # 카드 유형 (Phase 3)
         if card_type:
@@ -441,6 +864,11 @@ def handle_credit_cards(data: Any, context: Dict[str, Any]) -> List[Dict[str, An
                 elif isinstance(benefit, str):
                     content += f"  - {benefit}\n"
         
+        # evidence 정보 포함 (선택적)
+        evidence = card.get("evidence", [])
+        if evidence:
+            content += format_evidence(evidence, max_items=2)
+        
         content += DISCLAIMER_SHORT
         
         # 메타데이터에 추가 정보 포함
@@ -486,17 +914,39 @@ def handle_subscription_programs(data: Any, context: Dict[str, Any]) -> List[Dic
 기본 프로그램: {program.get('base_program_name', 'N/A')}
 """
         
-        # 플랜
+        # 플랜 (스키마: SubscriptionPlan.prices -> SubscriptionPlanPrice)
         plans = program.get("plans", [])
         for plan in plans[:5]:
             if isinstance(plan, dict):
                 plan_name = plan.get("plan_name", "N/A")
                 prices = plan.get("prices", [])
                 price_str = ""
-                if prices and isinstance(prices[0], dict):
-                    price = prices[0].get("price", {})
-                    price_str = f"{price.get('amount', 'N/A')} {price.get('currency', '')}/년"
-                
+
+                # 가격 처리 개선 (스키마에 맞춤)
+                if prices:
+                    for p in prices[:1]:  # 첫 번째 가격만
+                        if isinstance(p, dict):
+                            billing_cycle = p.get("billing_cycle", "YEARLY")
+                            price_info = p.get("price", {})
+                            if isinstance(price_info, dict):
+                                amount = price_info.get("amount", "N/A")
+                                currency = price_info.get("currency", "")
+
+                                # 결제 주기를 한국어로 변환
+                                cycle_kr = {
+                                    "YEARLY": "년",
+                                    "MONTHLY": "월",
+                                    "QUARTERLY": "분기",
+                                    "WEEKLY": "주"
+                                }.get(billing_cycle, billing_cycle.lower())
+
+                                if amount != "N/A" and currency:
+                                    price_str = f"{amount} {currency}/{cycle_kr}"
+                                else:
+                                    price_str = "가격 정보 없음"
+                            else:
+                                price_str = str(price_info) if price_info else "가격 정보 없음"
+
                 content += f"\n플랜: {plan_name}\n가격: {price_str}\n"
                 
                 # 플랜 혜택
@@ -811,45 +1261,235 @@ def handle_benefits(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
 # ===========================================================================
 
 def handle_best_rate_guarantee(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """best_rate_guarantee 처리"""
+    """best_rate_guarantee 처리 (스키마: BestRateGuarantee, BRGRule, BRGRemedy)
+    
+    청크 분리 전략:
+    1. 프로그램 개요 청크 (기본 정보, 제외 사항)
+    2. 규칙별 청크 (각 BRGRule을 개별 청크로)
+    """
     chunks = []
     chain = context.get("chain", "UNKNOWN")
     
     if not isinstance(data, dict):
         return chunks
     
-    content = f"""
-최저가 보장 (Best Rate Guarantee)
-체인: {chain}
-프로그램명: {data.get('program_name', 'N/A')}
-보상 유형: {data.get('compensation_type', 'N/A')}
+    program_name = data.get("program_name", "Best Rate Guarantee")
+    brg_chain = data.get("chain", chain)
+    
+    # === 청크 1: 프로그램 개요 ===
+    overview_content = f"""
+최저가 보장 프로그램: {program_name}
+체인: {brg_chain}
+멤버십 필요: {"예" if data.get("requires_membership") else "아니오"}
 """
     
-    # 이용 조건
-    conditions = data.get("conditions", [])
-    if conditions:
-        content += "\n이용 조건:\n"
-        for cond in conditions[:5]:
-            if isinstance(cond, dict):
-                content += f"- {cond.get('description', cond)}\n"
-            else:
-                content += f"- {cond}\n"
+    # 제외 사항 (스키마 필드)
+    excluded_regions = data.get("excluded_regions", [])
+    excluded_brands = data.get("excluded_brands", [])
+    excluded_hotels = data.get("excluded_hotels", [])
+    
+    if excluded_regions:
+        overview_content += f"제외 지역: {', '.join(excluded_regions[:5])}\n"
+    if excluded_brands:
+        overview_content += f"제외 브랜드: {', '.join(excluded_brands[:5])}\n"
+    if excluded_hotels:
+        overview_content += f"제외 호텔: {', '.join(excluded_hotels[:3])}\n"
+    
+    # 약관
+    if data.get("governing_law"):
+        overview_content += f"\n준거법: {data.get('governing_law')}\n"
+    if data.get("arbitration_clause"):
+        overview_content += "중재 조항: 포함\n"
     
-    # 제외 사항
-    exclusions = data.get("exclusions", [])
-    if exclusions:
-        content += "\n제외 사항:\n"
-        for exc in exclusions[:3]:
-            content += f"- {exc}\n" if isinstance(exc, str) else ""
+    # 마지막 업데이트
+    if data.get("last_updated"):
+        overview_content += f"마지막 업데이트: {data.get('last_updated')}\n"
+    
+    overview_content += DISCLAIMER_SHORT
     
     chunks.append({
-        "content": content.strip(),
+        "content": overview_content.strip(),
         "metadata": {
-            "type": "best_rate_guarantee",
-            "chain": chain
+            "type": "best_rate_guarantee_overview",
+            "program_name": program_name,
+            "chain": brg_chain
         }
     })
     
+    # === 청크 2+: 규칙별 상세 (스키마: BRGRule) ===
+    rules = data.get("rules", [])
+    for rule in rules[:5]:  # 최대 5개 규칙
+        if not isinstance(rule, dict):
+            continue
+        
+        rule_name = rule.get("rule_name", "N/A")
+        summary = rule.get("summary", "")
+        
+        rule_content = f"""
+{program_name} - {rule_name}
+체인: {brg_chain}
+
+"""
+        if summary:
+            rule_content += f"요약: {summary}\n\n"
+        
+        # 클레임 조건 (스키마 필드)
+        claim_window = rule.get("claim_window")
+        min_hours = rule.get("minimum_hours_before_checkin")
+        rate_diff = rule.get("rate_difference_threshold_percent")
+        max_rooms = rule.get("max_rooms_per_claim")
+        
+        if claim_window or min_hours or rate_diff or max_rooms:
+            rule_content += "클레임 조건:\n"
+            if claim_window:
+                rule_content += f"  - 클레임 가능 기간: {claim_window}\n"
+            if min_hours:
+                rule_content += f"  - 체크인 전 최소: {min_hours}시간\n"
+            if rate_diff:
+                rule_content += f"  - 최소 가격 차이: {rate_diff}%\n"
+            if max_rooms:
+                rule_content += f"  - 클레임당 최대 객실: {max_rooms}실\n"
+        
+        # 비교 기준
+        comparison = rule.get("comparison_criteria", [])
+        if comparison:
+            rule_content += f"\n비교 기준:\n"
+            for c in comparison[:6]:
+                rule_content += f"  - {c}\n"
+        
+        # 채널 요구사항
+        channel_reqs = rule.get("channel_requirements", [])
+        if channel_reqs:
+            rule_content += f"\n예약 채널: {', '.join(channel_reqs)}\n"
+        
+        # 적용/제외 요금
+        eligible_rates = rule.get("eligible_rates", [])
+        ineligible_rates = rule.get("ineligible_rates", [])
+        if eligible_rates:
+            rule_content += f"\n적용 요금:\n"
+            for r in eligible_rates[:5]:
+                rule_content += f"  - {r}\n"
+        if ineligible_rates:
+            rule_content += f"\n제외 요금:\n"
+            for r in ineligible_rates[:8]:
+                rule_content += f"  - {r}\n"
+        
+        # 보상 (스키마: BRGRemedy)
+        remedies = rule.get("remedies", [])
+        if remedies:
+            rule_content += "\n보상:\n"
+            for remedy in remedies[:3]:
+                if isinstance(remedy, dict):
+                    r_type = remedy.get("type", "N/A")
+                    r_desc = remedy.get("description", "")
+                    rule_content += f"  [{r_type}] {r_desc}\n"
+                    
+                    # 가치 (BenefitValue 구조)
+                    value = remedy.get("value", {})
+                    if isinstance(value, dict):
+                        v_type = value.get("type")
+                        v_text = value.get("text", "")
+                        if v_text:
+                            rule_content += f"    - 가치: {v_text}\n"
+                        elif v_type == "PERCENT" and value.get("percent"):
+                            rule_content += f"    - 가치: {value.get('percent')}%\n"
+                        elif v_type == "POINTS" and value.get("points"):
+                            rule_content += f"    - 가치: {value.get('points'):,}P\n"
+                    
+                    # 최대 보상 (Money 구조)
+                    max_val = remedy.get("max_value", {})
+                    if isinstance(max_val, dict) and max_val.get("amount"):
+                        rule_content += f"    - 최대: {max_val.get('amount'):,} {max_val.get('currency', '')}\n"
+        
+        # 추가 조건
+        conditions = rule.get("conditions", [])
+        if conditions:
+            rule_content += "\n추가 조건:\n"
+            for cond in conditions[:5]:
+                if isinstance(cond, dict):
+                    cond_summary = cond.get("summary", "")
+                    if cond_summary:
+                        rule_content += f"  - {cond_summary}\n"
+        
+        rule_content += DISCLAIMER_SHORT
+        
+        if len(rule_content) > 100:
+            chunks.append({
+                "content": rule_content.strip(),
+                "metadata": {
+                    "type": "best_rate_guarantee_rule",
+                    "program_name": program_name,
+                    "rule_name": rule_name,
+                    "chain": brg_chain
+                }
+            })
+    
+    # === 하위 호환: 기존 conditions 형식 지원 (rules가 없는 경우) ===
+    conditions = data.get("conditions", [])
+    if conditions and not rules:
+        cond_content = f"""
+{program_name} - 이용 조건
+체인: {brg_chain}
+
+이용 조건:
+"""
+        for cond in conditions[:5]:
+            if isinstance(cond, dict):
+                cond_content += f"  - {cond.get('description', cond.get('summary', cond))}\n"
+            else:
+                cond_content += f"  - {cond}\n"
+        
+        exclusions = data.get("exclusions", [])
+        if exclusions:
+            cond_content += "\n제외 사항:\n"
+            for exc in exclusions[:5]:
+                if isinstance(exc, str):
+                    cond_content += f"  - {exc}\n"
+        
+        cond_content += DISCLAIMER_SHORT
+        
+        chunks.append({
+            "content": cond_content.strip(),
+            "metadata": {
+                "type": "best_rate_guarantee_conditions",
+                "program_name": program_name,
+                "chain": brg_chain
+            }
+        })
+    
+    # === 청크: 클레임 거부 사유 (extra_attributes) ===
+    extra_attrs = data.get("extra_attributes", {})
+    if extra_attrs and isinstance(extra_attrs, dict):
+        rejection_reasons = extra_attrs.get("claim_rejection_reasons", [])
+        if rejection_reasons:
+            rejection_content = f"""
+{program_name} - 클레임 거부 사유
+체인: {brg_chain}
+
+클레임이 거부될 수 있는 사유:
+"""
+            for reason in rejection_reasons:
+                rejection_content += f"  - {reason}\n"
+            
+            # 추가 속성
+            if extra_attrs.get("nj_resident_exception"):
+                rejection_content += f"\n뉴저지 거주자 예외: {extra_attrs.get('nj_resident_exception')}\n"
+            if extra_attrs.get("modification_rights"):
+                rejection_content += f"프로그램 수정 권한: {extra_attrs.get('modification_rights')}\n"
+            if extra_attrs.get("employee_exclusion"):
+                rejection_content += f"직원 제외: {extra_attrs.get('employee_exclusion')}\n"
+            
+            rejection_content += DISCLAIMER_SHORT
+            
+            chunks.append({
+                "content": rejection_content.strip(),
+                "metadata": {
+                    "type": "best_rate_guarantee_rejection",
+                    "program_name": program_name,
+                    "chain": brg_chain
+                }
+            })
+    
     return chunks
 
 
@@ -858,23 +1498,41 @@ def handle_best_rate_guarantee(data: Any, context: Dict[str, Any]) -> List[Dict[
 # ===========================================================================
 
 def handle_channel_implementations(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """channel_implementations 처리"""
+    """channel_implementations 처리 - 국가/호텔명 정보 포함으로 검색 정확도 향상"""
     chunks = []
     chain = context.get("chain", "UNKNOWN")
     
     impls = data if isinstance(data, list) else [data]
     
-    for impl in impls[:5]:
+    for impl in impls[:10]:
         if not isinstance(impl, dict):
             continue
             
         program_name = impl.get("program_name", "N/A")
         hotel_id = impl.get("hotel_id", "N/A")
         
+        # extra_attributes에서 국가/호텔명 추출 (검색 정확도 향상)
+        extra = impl.get("extra_attributes", {})
+        country = extra.get("country", "")
+        hotel_name = extra.get("hotel_name", "")
+        region = extra.get("region", "")
+        
         content = f"""
 채널 프로그램: {program_name}
-호텔: {hotel_id}
-채널: {impl.get('channel', 'DIRECT')}
+"""
+        # 실제 호텔명이 있으면 우선 표시
+        if hotel_name:
+            content += f"호텔: {hotel_name}\n"
+        else:
+            content += f"호텔 ID: {hotel_id}\n"
+        
+        # 국가/지역 정보 (검색 매칭에 중요)
+        if country:
+            content += f"국가: {country}\n"
+        if region:
+            content += f"지역: {region}\n"
+            
+        content += f"""채널: {impl.get('channel', 'DIRECT')}
 """
         
         # 혜택 오버라이드
@@ -884,16 +1542,28 @@ def handle_channel_implementations(data: Any, context: Dict[str, Any]) -> List[D
             for override in overrides[:5]:
                 if isinstance(override, dict):
                     category = override.get("benefit_category", "N/A")
-                    detail = override.get("implementation_detail", "")[:80]
+                    detail = override.get("implementation_detail", "")[:100]
                     content += f"- {category}: {detail}\n"
+                    
+                    # 팁 추가
+                    tips = override.get("tips", [])
+                    for tip in tips[:2]:
+                        content += f"  → {tip}\n"
+        
+        # 메타데이터에도 국가 정보 포함
+        metadata = {
+            "type": "channel_implementation",
+            "program_name": program_name,
+            "hotel_id": hotel_id
+        }
+        if country:
+            metadata["country"] = country
+        if hotel_name:
+            metadata["hotel_name"] = hotel_name
         
         chunks.append({
             "content": content.strip(),
-            "metadata": {
-                "type": "channel_implementation",
-                "program_name": program_name,
-                "hotel_id": hotel_id
-            }
+            "metadata": metadata
         })
     
     return chunks
@@ -904,7 +1574,7 @@ def handle_channel_implementations(data: Any, context: Dict[str, Any]) -> List[D
 # ===========================================================================
 
 def handle_channel_benefit_packages(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """channel_benefit_packages 처리 (FHR, THC 등)"""
+    """channel_benefit_packages 처리 (FHR, THC 등) - 스키마: ChannelBenefitPackage"""
     chunks = []
     
     packages = data if isinstance(data, list) else [data]
@@ -921,15 +1591,47 @@ def handle_channel_benefit_packages(data: Any, context: Dict[str, Any]) -> List[
 채널: {channel}
 """
         
-        # 혜택 목록
-        benefits = pkg.get("benefits", pkg.get("included_benefits", []))
+        # 특정 요금제 필요 여부
+        if pkg.get("requires_specific_rate"):
+            content += "특정 요금제 필요: 예\n"
+            eligible_rates = pkg.get("eligible_rates", [])
+            if eligible_rates:
+                content += f"적용 가능 요금: {', '.join(eligible_rates)}\n"
+        
+        # 스키마 필드명: standard_benefits
+        # 하위 호환: benefits, included_benefits도 지원
+        benefits = pkg.get("standard_benefits", pkg.get("benefits", pkg.get("included_benefits", [])))
         if benefits:
             content += "\n포함 혜택:\n"
-            for benefit in benefits[:6]:
+            for benefit in benefits[:8]:
                 if isinstance(benefit, dict):
-                    content += f"- {benefit.get('name', 'N/A')}: {benefit.get('description', '')[:60]}\n"
+                    ben_name = benefit.get("name", benefit.get("benefit_name", "N/A"))
+                    ben_desc = benefit.get("description", "")[:60]
+                    ben_category = benefit.get("category", "")
+                    
+                    content += f"  - {ben_name}"
+                    if ben_category:
+                        content += f" [{ben_category}]"
+                    if ben_desc:
+                        content += f": {ben_desc}"
+                    content += "\n"
+                    
+                    # 가치 표시 (BenefitValue 구조)
+                    value = benefit.get("value", {})
+                    if isinstance(value, dict):
+                        v_type = value.get("type")
+                        if v_type == "MONEY" and value.get("money"):
+                            money = value.get("money", {})
+                            content += f"    가치: {money.get('amount', 'N/A')} {money.get('currency', '')}\n"
+                        elif v_type == "TEXT" and value.get("text"):
+                            content += f"    가치: {value.get('text')}\n"
+                        elif v_type == "PERCENT" and value.get("percent"):
+                            content += f"    가치: {value.get('percent')}%\n"
+                            
                 elif isinstance(benefit, str):
-                    content += f"- {benefit}\n"
+                    content += f"  - {benefit}\n"
+        
+        content += DISCLAIMER_SHORT
         
         chunks.append({
             "content": content.strip(),
@@ -948,31 +1650,90 @@ def handle_channel_benefit_packages(data: Any, context: Dict[str, Any]) -> List[
 # ===========================================================================
 
 def handle_member_rates(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """member_rates 처리 (회원 전용 요금)"""
+    """member_rates 처리 (회원 전용 요금) - 스키마 MemberRate 필드 구조에 맞춤"""
     chunks = []
     chain = context.get("chain", "UNKNOWN")
-    
+
     if data is None:
         return chunks
-    
+
     rates = data if isinstance(data, list) else [data]
-    
+
     for rate in rates[:5]:
         if not isinstance(rate, dict):
             continue
-        
+
         rate_name = rate.get("rate_name", rate.get("name", "N/A"))
-        
+
         content = f"""
 회원 요금: {rate_name}
 체인: {rate.get('chain', chain)}
-할인율: {rate.get('discount_percentage', rate.get('discount', 'N/A'))}%
-적용 조건: {rate.get('conditions', rate.get('eligibility', 'N/A'))}
 """
-        
+
+        # 할인율 (스키마 구조 반영)
+        weekday_discount = rate.get("weekday_discount_percent")
+        weekend_discount = rate.get("weekend_discount_percent")
+        min_discount = rate.get("minimum_discount_percent")
+        max_discount = rate.get("maximum_discount_percent")
+
+        # 하위 호환성: 기존 필드도 지원
+        legacy_discount = rate.get("discount_percentage", rate.get("discount"))
+
+        if weekday_discount or weekend_discount:
+            content += "할인율:\n"
+            if weekday_discount:
+                content += f"  - 평일: {weekday_discount}%\n"
+            if weekend_discount:
+                content += f"  - 주말: {weekend_discount}%\n"
+        elif min_discount or max_discount:
+            content += f"할인율: {min_discount or '?'}% ~ {max_discount or '?'}%\n"
+        elif legacy_discount and legacy_discount != "N/A":
+            content += f"할인율: {legacy_discount}%\n"
+
+        # 필수 멤버십
+        if rate.get("requires_membership", True):
+            content += "멤버십 필요: 예\n"
+            if rate.get("minimum_tier"):
+                content += f"최소 등급: {rate.get('minimum_tier')}\n"
+
+        # 적용 객실
+        applies_to = rate.get("applies_to_room_types", [])
+        excluded = rate.get("excluded_room_types", [])
+        if applies_to:
+            content += f"적용 객실: {', '.join(applies_to)}\n"
+        if excluded:
+            content += f"제외 객실: {', '.join(excluded)}\n"
+
+        # 예약 채널
+        channels = rate.get("eligible_channels", [])
+        if channels:
+            content += f"예약 채널: {', '.join(channels)}\n"
+
+        # 제한사항
+        max_rooms = rate.get("max_rooms")
+        if max_rooms:
+            content += f"최대 객실: {max_rooms}실\n"
+
+        excluded_rate_types = rate.get("excluded_rate_types", [])
+        if excluded_rate_types:
+            content += f"제외 요금 유형: {', '.join(excluded_rate_types)}\n"
+
+        excluded_hotels = rate.get("excluded_hotels", [])
+        if excluded_hotels:
+            content += f"제외 호텔: {', '.join(excluded_hotels[:3])}\n"
+
+        # 중복 적용
+        if rate.get("combinable_with_promotions"):
+            content += "다른 프로모션과 중복 가능\n"
+
+        # 하위 호환성: 기존 필드들
+        legacy_conditions = rate.get("conditions", rate.get("eligibility"))
+        if legacy_conditions and legacy_conditions != "N/A":
+            content += f"적용 조건: {legacy_conditions}\n"
+
         if rate.get("description"):
             content += f"설명: {rate.get('description')}\n"
-        
+
         chunks.append({
             "content": content.strip(),
             "metadata": {
@@ -981,7 +1742,7 @@ def handle_member_rates(data: Any, context: Dict[str, Any]) -> List[Dict[str, An
                 "chain": rate.get("chain", chain)
             }
         })
-    
+
     return chunks
 
 
@@ -1304,44 +2065,43 @@ def handle_dining_programs(data: Any, context: Dict[str, Any]) -> List[Dict[str,
                 if min_spend:
                     content += f"    - 최소 소비 금액: ${min_spend}\n"
 
-        # facts 정보 추가
-        facts = context.get("facts", {})
-        if isinstance(facts, dict):
-            # 프로그램 세부사항
-            program_details = facts.get("program_details", {})
-            if program_details:
-                content += "\n프로그램 세부사항:\n"
-                total_outlets = program_details.get("total_participating_outlets")
-                if total_outlets:
-                    content += f"  - 참여 매장 수: {total_outlets}개\n"
-                coverage = program_details.get("coverage")
-                if coverage:
-                    content += f"  - 커버리지: {coverage}\n"
-                outlet_types = program_details.get("outlet_types", [])
-                if outlet_types:
-                    content += f"  - 매장 유형: {', '.join(outlet_types)}\n"
-
-            # 제한사항
-            restrictions = facts.get("restrictions", {})
-            if restrictions:
+        # 프로그램 추가 정보 (스키마 필드 기반)
+        # 참여 매장 정보
+        participating_outlets = program.get("participating_outlets")
+        if participating_outlets:
+            content += f"\n참여 매장 수: {participating_outlets}개\n"
+
+        outlet_types = program.get("outlet_types", [])
+        if outlet_types:
+            content += f"매장 유형: {', '.join(outlet_types)}\n"
+
+        # 제한사항
+        restrictions_added = False
+        max_group = program.get("max_group_size")
+        if max_group:
+            if not restrictions_added:
+                content += "\n제한사항:\n"
+                restrictions_added = True
+            content += f"  - 최대 그룹 크기: {max_group}명\n"
+
+        split_bills = program.get("split_bills_allowed")
+        if split_bills is not None:
+            if not restrictions_added:
+                content += "\n제한사항:\n"
+                restrictions_added = True
+            content += f"  - 분할 결제: {'허용' if split_bills else '불허용'}\n"
+
+        member_present = program.get("member_must_be_present")
+        if member_present is not None:
+            if not restrictions_added:
                 content += "\n제한사항:\n"
-                max_group = restrictions.get("max_group_size")
-                if max_group:
-                    content += f"  - 최대 그룹 크기: {max_group}명\n"
-                split_bills = restrictions.get("split_bills_allowed")
-                if split_bills is not None:
-                    content += f"  - 분할 결제: {'허용' if split_bills else '불허용'}\n"
-                member_present = restrictions.get("member_must_be_present")
-                if member_present is not None:
-                    content += f"  - 회원 동석: {'필수' if member_present else '불필요'}\n"
-
-            # 제외사항
-            exclusions = facts.get("exclusions", [])
-            if exclusions:
-                content += "\n제외사항:\n"
-                for exclusion in exclusions:
-                    if isinstance(exclusion, str):
-                        content += f"  - {exclusion.replace('_', ' ')}\n"
+                restrictions_added = True
+            content += f"  - 회원 본인 참석: {'필수' if member_present else '불필요'}\n"
+
+        # 제외사항
+        exclusions = program.get("exclusions", [])
+        if exclusions:
+            content += f"\n제외사항: {', '.join(exclusions[:3])}\n"
 
         content += DISCLAIMER_SHORT
 
@@ -1434,7 +2194,10 @@ def handle_airline_programs(data: Any, context: Dict[str, Any]) -> List[Dict[str
 def handle_airline_tiers(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
     """airline_tiers 처리"""
     chunks = []
-    
+
+    if data is None:
+        return chunks
+
     tiers = data if isinstance(data, list) else [data]
     
     for tier in tiers[:10]:
@@ -1443,14 +2206,18 @@ def handle_airline_tiers(data: Any, context: Dict[str, Any]) -> List[Dict[str, A
         
         tier_name = tier.get("tier_name", "N/A")
         airline = tier.get("airline", context.get("chain", "UNKNOWN"))
-        
+
+        # f-string 오류 수정: miles_required 처리
+        miles_req = tier.get("miles_required")
+        miles_str = f"{miles_req:,}" if isinstance(miles_req, int) else "N/A"
+
         content = f"""
 항공 멤버십 등급: {tier_name}
 항공사: {airline}
 등급 순위: {tier.get("rank", "N/A")}
 
 자격 요건:
-  - 필요 마일리지: {tier.get("miles_required", "N/A"):,} if isinstance(tier.get("miles_required"), int) else "N/A"
+  - 필요 마일리지: {miles_str}
   - 필요 구간: {tier.get("segments_required", "N/A")}
   - 산정 기간: {tier.get("qualification_period", "calendar_year")}
 """
@@ -1563,47 +2330,80 @@ def handle_award_charts(data: Any, context: Dict[str, Any]) -> List[Dict[str, An
 
 
 def handle_airline_earning_rules(data: Any, context: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """airline_earning_rules 처리"""
+    """airline_earning_rules 처리 (스키마 AirlineEarningRule 필드 구조에 맞춤)"""
     chunks = []
-    
+
     rules = data if isinstance(data, list) else [data]
     airline = context.get("chain", "UNKNOWN")
-    
+
     # 규칙들을 하나의 청크로 묶기
     if not rules:
         return chunks
-    
+
     content = f"""
 마일리지 적립 규칙
 항공사: {airline}
 
 """
-    
+
     for rule in rules[:15]:
         if not isinstance(rule, dict):
             continue
-        
+
         rule_name = rule.get("rule_name", "N/A")
         cabin = rule.get("cabin_class", "")
-        rate = rule.get("earning_rate_percent", "N/A")
-        route = rule.get("route_type", "")
-        
+
         content += f"• {rule_name}\n"
         if cabin:
             content += f"  - 객실: {cabin}\n"
+
+        # 노선 유형
+        route = rule.get("route_type", "")
         if route:
             content += f"  - 노선: {route}\n"
-        content += f"  - 적립률: {rate}%\n"
-        
-        if rule.get("booking_classes"):
-            content += f"  - 예약 클래스: {', '.join(rule['booking_classes'])}\n"
-        if rule.get("bonus_miles"):
-            content += f"  - 보너스: +{rule['bonus_miles']:,} 마일\n"
-        
+
+        # 적립률 (스키마 필드 반영)
+        earning_rate = rule.get("earning_rate_percent")
+        base_miles_type = rule.get("base_miles_type", "FLOWN")
+        fixed_miles = rule.get("fixed_miles")
+
+        if earning_rate:
+            content += f"  - 적립률: {earning_rate}%\n"
+        elif base_miles_type == "FIXED" and fixed_miles:
+            content += f"  - 고정 마일: {fixed_miles:,}마일\n"
+
+        # 예약 클래스
+        booking_classes = rule.get("booking_classes", [])
+        if booking_classes:
+            content += f"  - 예약 클래스: {', '.join(booking_classes)}\n"
+
+        # 보너스 마일
+        bonus_miles = rule.get("bonus_miles")
+        if bonus_miles:
+            content += f"  - 보너스: +{bonus_miles:,}마일\n"
+
+        # 필요 등급
+        req_tier = rule.get("requires_membership_tier")
+        if req_tier:
+            content += f"  - 필요 등급: {req_tier}\n"
+
+        # 유효 기간
+        validity = rule.get("validity")
+        if validity and isinstance(validity, dict):
+            start = validity.get("start_date")
+            end = validity.get("end_date")
+            if start or end:
+                content += f"  - 유효 기간: {start or '?'} ~ {end or '?'}\n"
+
+        # 지역
+        region = rule.get("region")
+        if region and region != "GLOBAL":
+            content += f"  - 적용 지역: {region}\n"
+
         content += "\n"
-    
+
     content += DISCLAIMER_SHORT
-    
+
     if len(content) > 100:
         chunks.append({
             "content": content.strip(),
@@ -1612,7 +2412,7 @@ def handle_airline_earning_rules(data: Any, context: Dict[str, Any]) -> List[Dic
                 "airline": airline
             }
         })
-    
+
     return chunks
 
 
@@ -1809,7 +2609,15 @@ CHUNK_HANDLERS = {
 
     # 멤버십 등급
     "membership_tiers": handle_membership_tiers,
-    "milestone_program": handle_membership_tiers,  # 마일스톤은 멤버십 관련이므로 동일 핸들러 사용
+    
+    # 마일스톤 프로그램
+    "milestone_program": handle_milestone_programs,
+    "milestone_programs": handle_milestone_programs,
+    "milestones": handle_milestone_programs,
+    
+    # 파트너 등급 매칭
+    "partner_status_matches": handle_partner_status_matches,
+    "partner_status_match": handle_partner_status_matches,
 
     # 포인트 시스템
     "points_systems": handle_points_systems,
@@ -1817,6 +2625,7 @@ CHUNK_HANDLERS = {
 
     # 호텔
     "hotel_properties": handle_hotel_properties,
+    "hotel_brands": handle_hotel_brands,
 
     # 등급별 구현
     "tier_implementations": handle_tier_implementations,
@@ -1975,7 +2784,7 @@ IGNORED_KEYS = {
     "facts",
     
     # Core 키에 포함되므로 별도 처리 불필요
-    "hotel_brands",  # hotel_properties에 포함
+    # "hotel_brands",  # 이제 handle_hotel_brands로 처리
     "nearby_attractions",  # extra_attributes에 포함
     
     # 검색 가치 낮음

scripts/sync_to_supabase.py

@@ -77,12 +77,24 @@ def create_chunks_from_knowledge(
             name_localized = first_hotel.get("name_localized", {})
             hotel_name_ko = name_localized.get("ko") if isinstance(name_localized, dict) else None
     
+    # identity 섹션에서 추가 정보 추출 (프롬프트 출력 호환성)
+    identity = extracted_knowledge.get("identity", {})
+    if identity and isinstance(identity, dict):
+        # identity에서 정보 보강
+        if identity.get("title") and hotel_name == "Unknown Hotel":
+            hotel_name = identity.get("title")
+        if identity.get("chain"):
+            chain = identity.get("chain", chain)
+    
     # 컨텍스트 생성
     context = {
         "chain": chain,
         "hotel_name": hotel_name,
         "hotel_name_ko": hotel_name_ko,
         "doc_id": doc_id,
+        # identity 추가 정보
+        "document_category": identity.get("category") if identity else None,
+        "document_type": identity.get("document_type") if identity else None,
     }
     
     def add_chunk(content: str, metadata: Dict[str, Any]):
@@ -327,7 +339,23 @@ def main(chain: Optional[str], domain: str, dry_run: bool, skip_embeddings: bool
         extracted_knowledge = data.get("extracted_knowledge")
         if not extracted_knowledge or not isinstance(extracted_knowledge, dict):
             # extracted_knowledge가 없으면 data 자체가 knowledge일 수 있음
-            if "hotel_properties" in data or "loyalty_programs" in data or "membership_tiers" in data or "tier_implementations" in data:
+            # 다양한 도메인의 핵심 키들을 체크
+            core_keys = {
+                # 호텔
+                "hotel_properties", "loyalty_programs", "loyalty_program",
+                "membership_tiers", "tier_implementations", "hotel_brands",
+                "best_rate_guarantee", "channel_benefit_packages",
+                # 항공
+                "airline_programs", "airline_program", "airline_tiers",
+                "award_charts", "airline_earning_rules",
+                # 카드
+                "credit_cards",
+                # 프로모션/뉴스
+                "deal_alerts", "news_updates", "promotions",
+                # 기타
+                "points_systems", "member_rates", "dining_programs",
+            }
+            if any(key in data for key in core_keys):
                 extracted_knowledge = data
             else:
                 if verbose:
@@ -336,7 +364,21 @@ def main(chain: Optional[str], domain: str, dry_run: bool, skip_embeddings: bool
                 continue
         
         # 문서 ID 생성
-        rel_path = str(md_file.relative_to(data_dir.parent.parent))
+        # --file 옵션 사용 시 data_dir가 없을 수 있으므로 파일 경로에서 직접 계산
+        try:
+            # data/raw 기준으로 상대 경로 계산
+            data_raw = Path("data/raw")
+            if md_file.is_relative_to(data_raw):
+                rel_path = str(md_file.relative_to(data_raw.parent))
+            elif "data/raw" in str(md_file):
+                # 절대 경로인 경우 data/raw 이후 부분 추출
+                path_str = str(md_file)
+                idx = path_str.find("data/raw")
+                rel_path = path_str[idx:] if idx >= 0 else str(md_file.name)
+            else:
+                rel_path = str(md_file)
+        except Exception:
+            rel_path = str(md_file)
         doc_id = generate_doc_id(rel_path)
         
         # 청크 생성