Update cache_db.py

cache_db.py

@@ -1,7 +1,9 @@
 """
 과제 공고 벡터 DB 캐시 시스템
 - ChromaDB를 사용한 로컬 캐시
+- 메타 캐시 + 본문 벡터 캐시 (2개 컬렉션)
 - 매일 KST 10:00, 22:00 자동 동기화
+- 백그라운드 본문 인덱싱 (서비스 무중단)
 - Hugging Face Space 영구 스토리지 활용 (/data)
 """
 import os
@@ -9,25 +11,21 @@ import json
 import hashlib
 import threading
 import logging
+import tempfile
+import time
 from datetime import datetime, timedelta
-from typing import List, Dict, Tuple, Optional
+from typing import List, Dict, Tuple, Optional, Generator
 from pathlib import Path
 import pytz
-
-# 로깅 설정
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-
-# 영구 스토리지 경로 (HF Space)
 PERSISTENT_DIR = Path("/data") if os.path.exists("/data") else Path("./data")
 CACHE_DIR = PERSISTENT_DIR / "announcement_cache"
 DB_PATH = CACHE_DIR / "chroma_db"
+CONTENT_DB_PATH = CACHE_DIR / "content_db"
 METADATA_FILE = CACHE_DIR / "sync_metadata.json"
-
-# 디렉토리 생성
+CONTENT_INDEX_FILE = CACHE_DIR / "content_index_status.json"
 CACHE_DIR.mkdir(parents=True, exist_ok=True)
-
-# ChromaDB 사용 가능 여부
 try:
     import chromadb
     from chromadb.config import Settings
@@ -35,8 +33,6 @@ try:
 except ImportError:
     CHROMADB_AVAILABLE = False
     logger.warning("ChromaDB not available. Using JSON fallback.")
-
-# APScheduler 사용 가능 여부
 try:
     from apscheduler.schedulers.background import BackgroundScheduler
     from apscheduler.triggers.cron import CronTrigger
@@ -44,30 +40,39 @@ try:
 except ImportError:
     SCHEDULER_AVAILABLE = False
     logger.warning("APScheduler not available. Auto-sync disabled.")
-
-# 한국 시간대
+try:
+    from sentence_transformers import SentenceTransformer
+    EMBEDDING_AVAILABLE = True
+except ImportError:
+    EMBEDDING_AVAILABLE = False
+    logger.warning("sentence-transformers not available. Using ChromaDB default embedding.")
 KST = pytz.timezone('Asia/Seoul')
-
-
+_embedding_model = None
+def get_embedding_model():
+    """임베딩 모델 싱글톤"""
+    global _embedding_model
+    if _embedding_model is None and EMBEDDING_AVAILABLE:
+        try:
+            _embedding_model = SentenceTransformer('jhgan/ko-sroberta-multitask')
+            logger.info("Loaded Korean embedding model: jhgan/ko-sroberta-multitask")
+        except Exception as e:
+            logger.error(f"Failed to load embedding model: {e}")
+    return _embedding_model
 def safe_str(value, max_len=None) -> str:
-    """None-safe 문자열 변환 (전역 헬퍼)"""
+    """None-safe 문자열 변환"""
     if value is None:
         return ""
     s = str(value)
     if max_len and len(s) > max_len:
         return s[:max_len]
     return s
-
-
 class AnnouncementCache:
-    """공고 캐시 관리 클래스"""
-    
+    """공고 메타정보 캐시 관리 클래스"""
     def __init__(self):
         self.collection = None
         self.client = None
         self._init_db()
         self._load_metadata()
-    
     def _init_db(self):
         """ChromaDB 초기화"""
         if CHROMADB_AVAILABLE:
@@ -78,7 +83,7 @@ class AnnouncementCache:
                 )
                 self.collection = self.client.get_or_create_collection(
                     name="announcements",
-                    metadata={"description": "기업마당 과제 공고 캐시"}
+                    metadata={"description": "기업마당 과제 공고 메타 캐시"}
                 )
                 logger.info(f"ChromaDB initialized at {DB_PATH}")
             except Exception as e:
@@ -86,7 +91,6 @@ class AnnouncementCache:
                 self.collection = None
         else:
             logger.info("Using JSON fallback storage")
-    
     def _load_metadata(self):
         """동기화 메타데이터 로드"""
         self.metadata = {
@@ -100,7 +104,6 @@ class AnnouncementCache:
                     self.metadata = json.load(f)
             except Exception as e:
                 logger.error(f"Metadata load error: {e}")
-    
     def _save_metadata(self):
         """동기화 메타데이터 저장"""
         try:
@@ -108,7 +111,6 @@ class AnnouncementCache:
                 json.dump(self.metadata, f, ensure_ascii=False, indent=2)
         except Exception as e:
             logger.error(f"Metadata save error: {e}")
-    
     def _generate_id(self, item: Dict) -> str:
         """공고 고유 ID 생성"""
         pblanc_id = safe_str(item.get("pblancId") or item.get("seq", ""))
@@ -116,12 +118,9 @@ class AnnouncementCache:
         pub_date = safe_str(item.get("pubDate") or item.get("creatPnttm", ""))
         unique_str = f"{pblanc_id}-{title}-{pub_date}"
         return hashlib.md5(unique_str.encode()).hexdigest()
-    
     def _item_to_document(self, item: Dict) -> Tuple[str, str, Dict]:
         """API 아이템을 ChromaDB 문서로 변환"""
         doc_id = self._generate_id(item)
-        
-        # 검색 가능한 텍스트 생성
         text_parts = [
             safe_str(item.get("title")),
             safe_str(item.get("pblancNm")),
@@ -135,12 +134,8 @@ class AnnouncementCache:
             safe_str(item.get("excInsttNm")),
         ]
         searchable_text = " ".join([t for t in text_parts if t])
-        
-        # 빈 텍스트 방지
         if not searchable_text.strip():
             searchable_text = "공고"
-        
-        # 메타데이터 (모든 값에 safe_str 적용)
         metadata = {
             "pblancId": safe_str(item.get("pblancId") or item.get("seq")),
             "title": safe_str(item.get("title") or item.get("pblancNm"), 500),
@@ -156,13 +151,13 @@ class AnnouncementCache:
             "inqireCo": safe_str(item.get("inqireCo") or "0"),
             "flpthNm": safe_str(item.get("flpthNm"), 500),
             "fileNm": safe_str(item.get("fileNm"), 200),
+            "printFlpthNm": safe_str(item.get("printFlpthNm"), 500),
+            "printFileNm": safe_str(item.get("printFileNm"), 200),
             "refrncNm": safe_str(item.get("refrncNm"), 200),
             "rceptEngnHmpgUrl": safe_str(item.get("rceptEngnHmpgUrl"), 500),
             "cached_at": datetime.now(KST).isoformat(),
         }
-        
         return doc_id, searchable_text, metadata
-    
     def get_count(self) -> int:
         """캐시된 공고 수 반환"""
         if self.collection:
@@ -171,17 +166,14 @@ class AnnouncementCache:
             except:
                 return 0
         return self.metadata.get("total_count", 0)
-    
     def get_all(self) -> List[Dict]:
         """모든 캐시된 공고 반환"""
         if not self.collection:
             return self._get_all_from_json()
-        
         try:
             count = self.collection.count()
             if count == 0:
                 return []
-            
             result = self.collection.get(include=["metadatas"])
             items = []
             for meta in result.get("metadatas", []):
@@ -191,7 +183,6 @@ class AnnouncementCache:
         except Exception as e:
             logger.error(f"Get all error: {e}")
             return self._get_all_from_json()
-    
     def _metadata_to_item(self, meta: Dict) -> Dict:
         """메타데이터를 원본 아이템 형식으로 변환"""
         return {
@@ -217,10 +208,11 @@ class AnnouncementCache:
             "inqireCo": safe_str(meta.get("inqireCo")),
             "flpthNm": safe_str(meta.get("flpthNm")),
             "fileNm": safe_str(meta.get("fileNm")),
+            "printFlpthNm": safe_str(meta.get("printFlpthNm")),
+            "printFileNm": safe_str(meta.get("printFileNm")),
             "refrncNm": safe_str(meta.get("refrncNm")),
             "rceptEngnHmpgUrl": safe_str(meta.get("rceptEngnHmpgUrl")),
         }
-    
     def _get_all_from_json(self) -> List[Dict]:
         """JSON 폴백에서 모든 공고 로드"""
         json_file = CACHE_DIR / "announcements.json"
@@ -231,7 +223,6 @@ class AnnouncementCache:
             except:
                 return []
         return []
-    
     def _save_to_json(self, items: List[Dict]):
         """JSON 폴백으로 저장"""
         json_file = CACHE_DIR / "announcements.json"
@@ -241,18 +232,14 @@ class AnnouncementCache:
             logger.info(f"Saved {len(items)} items to JSON fallback")
         except Exception as e:
             logger.error(f"JSON save error: {e}")
-    
     def bulk_upsert(self, items: List[Dict]) -> Tuple[int, int]:
         """대량 삽입/업데이트"""
         if not items:
             return 0, 0
-        
         added = 0
         updated = 0
-        
         if self.collection:
             try:
-                # 기존 ID 목록 가져오기
                 existing = set()
                 try:
                     count = self.collection.count()
@@ -263,18 +250,15 @@ class AnnouncementCache:
                 except Exception as e:
                     logger.warning(f"Failed to get existing IDs: {e}")
                     existing = set()
-                
                 ids = []
                 documents = []
                 metadatas = []
-                
                 for item in items:
                     try:
                         doc_id, doc_text, meta = self._item_to_document(item)
                         ids.append(doc_id)
                         documents.append(doc_text)
                         metadatas.append(meta)
-                        
                         if doc_id in existing:
                             updated += 1
                         else:
@@ -282,67 +266,51 @@ class AnnouncementCache:
                     except Exception as e:
                         logger.warning(f"Failed to process item: {e}")
                         continue
-                
                 if not ids:
                     logger.warning("No valid items to upsert")
                     return 0, 0
-                
-                # 배치 단위로 upsert (ChromaDB 제한 고려)
                 batch_size = 100
                 for i in range(0, len(ids), batch_size):
                     batch_ids = ids[i:i+batch_size]
                     batch_docs = documents[i:i+batch_size]
                     batch_metas = metadatas[i:i+batch_size]
-                    
                     self.collection.upsert(
                         ids=batch_ids,
                         documents=batch_docs,
                         metadatas=batch_metas
                     )
                     logger.info(f"Upserted batch {i//batch_size + 1}: {len(batch_ids)} items")
-                
                 logger.info(f"Bulk upsert complete: {added} added, {updated} updated")
-                
             except Exception as e:
                 logger.error(f"Bulk upsert error: {e}")
                 import traceback
                 logger.error(traceback.format_exc())
-                # JSON 폴백
                 self._save_to_json(items)
                 added = len(items)
         else:
-            # JSON 폴백
             self._save_to_json(items)
             added = len(items)
-        
-        # 메타데이터 업데이트
         self.metadata["total_count"] = self.get_count()
         self.metadata["last_sync"] = datetime.now(KST).isoformat()
         self._save_metadata()
-        
         return added, updated
-    
     def search(self, query: str, n_results: int = 20) -> List[Dict]:
         """텍스트 검색"""
         if not self.collection or not query.strip():
             return self.get_all()[:n_results]
-        
         try:
             result = self.collection.query(
                 query_texts=[query],
                 n_results=n_results,
                 include=["metadatas"]
             )
-            
             items = []
             for meta in result.get("metadatas", [[]])[0]:
                 items.append(self._metadata_to_item(meta))
             return items
-            
         except Exception as e:
             logger.error(f"Search error: {e}")
             return []
-    
     def get_existing_ids(self) -> set:
         """기존 공고 ID 집합 반환"""
         if self.collection:
@@ -354,56 +322,300 @@ class AnnouncementCache:
                 return {safe_str(meta.get("pblancId")) for meta in result.get("metadatas", [])}
             except:
                 return set()
-        
         items = self._get_all_from_json()
         return {safe_str(item.get("pblancId") or item.get("seq")) for item in items}
-
-
-# 글로벌 캐시 인스턴스
+class ContentVectorCache:
+    """공고 본문 벡터 캐시 관리 클래스 (매칭용)"""
+    def __init__(self):
+        self.collection = None
+        self.client = None
+        self.index_status = {}
+        self._init_db()
+        self._load_index_status()
+    def _init_db(self):
+        """본문 벡터 DB 초기화"""
+        if CHROMADB_AVAILABLE:
+            try:
+                self.client = chromadb.PersistentClient(
+                    path=str(CONTENT_DB_PATH),
+                    settings=Settings(anonymized_telemetry=False)
+                )
+                self.collection = self.client.get_or_create_collection(
+                    name="announcement_contents",
+                    metadata={"description": "공고 본문 벡터 캐시 (매칭용)"}
+                )
+                logger.info(f"Content VectorDB initialized at {CONTENT_DB_PATH}")
+            except Exception as e:
+                logger.error(f"Content VectorDB init error: {e}")
+                self.collection = None
+    def _load_index_status(self):
+        """인덱싱 상태 로드"""
+        self.index_status = {
+            "total_indexed": 0,
+            "last_index_time": None,
+            "indexed_ids": [],
+            "failed_ids": [],
+            "in_progress": False,
+            "progress_current": 0,
+            "progress_total": 0
+        }
+        if CONTENT_INDEX_FILE.exists():
+            try:
+                with open(CONTENT_INDEX_FILE, 'r', encoding='utf-8') as f:
+                    self.index_status = json.load(f)
+            except Exception as e:
+                logger.error(f"Index status load error: {e}")
+    def _save_index_status(self):
+        """인덱싱 상태 저장"""
+        try:
+            with open(CONTENT_INDEX_FILE, 'w', encoding='utf-8') as f:
+                json.dump(self.index_status, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            logger.error(f"Index status save error: {e}")
+    def get_indexed_count(self) -> int:
+        """인덱싱된 본문 수"""
+        if self.collection:
+            try:
+                return self.collection.count()
+            except:
+                return 0
+        return len(self.index_status.get("indexed_ids", []))
+    def get_indexed_ids(self) -> set:
+        """이미 인덱싱된 공고 ID 집합"""
+        if self.collection:
+            try:
+                count = self.collection.count()
+                if count == 0:
+                    return set()
+                result = self.collection.get(include=["metadatas"])
+                return {safe_str(meta.get("pblancId")) for meta in result.get("metadatas", [])}
+            except:
+                return set()
+        return set(self.index_status.get("indexed_ids", []))
+    def add_content(self, pblanc_id: str, title: str, content_text: str, 
+                    structured_info: Dict = None) -> bool:
+        """본문 콘텐츠 추가"""
+        if not self.collection or not content_text.strip():
+            return False
+        try:
+            doc_id = hashlib.md5(pblanc_id.encode()).hexdigest()
+            metadata = {
+                "pblancId": safe_str(pblanc_id),
+                "title": safe_str(title, 500),
+                "content_length": len(content_text),
+                "indexed_at": datetime.now(KST).isoformat(),
+            }
+            if structured_info:
+                metadata["eligibility"] = safe_str(json.dumps(structured_info.get("eligibility", {}), ensure_ascii=False), 2000)
+                metadata["support_details"] = safe_str(json.dumps(structured_info.get("support_details", {}), ensure_ascii=False), 2000)
+                metadata["evaluation_criteria"] = safe_str(json.dumps(structured_info.get("evaluation_criteria", {}), ensure_ascii=False), 2000)
+            embedding = None
+            model = get_embedding_model()
+            if model:
+                try:
+                    summary_text = content_text[:2000]
+                    embedding = model.encode(summary_text).tolist()
+                except Exception as e:
+                    logger.warning(f"Embedding generation failed: {e}")
+            if embedding:
+                self.collection.upsert(
+                    ids=[doc_id],
+                    embeddings=[embedding],
+                    documents=[content_text[:10000]],
+                    metadatas=[metadata]
+                )
+            else:
+                self.collection.upsert(
+                    ids=[doc_id],
+                    documents=[content_text[:10000]],
+                    metadatas=[metadata]
+                )
+            if pblanc_id not in self.index_status.get("indexed_ids", []):
+                self.index_status.setdefault("indexed_ids", []).append(pblanc_id)
+            self.index_status["total_indexed"] = self.get_indexed_count()
+            self.index_status["last_index_time"] = datetime.now(KST).isoformat()
+            return True
+        except Exception as e:
+            logger.error(f"Add content error for {pblanc_id}: {e}")
+            if pblanc_id not in self.index_status.get("failed_ids", []):
+                self.index_status.setdefault("failed_ids", []).append(pblanc_id)
+            return False
+    def search_similar(self, query_text: str, n_results: int = 20) -> List[Dict]:
+        """유사 공고 검색 (벡터 검색)"""
+        if not self.collection:
+            return []
+        try:
+            model = get_embedding_model()
+            if model:
+                query_embedding = model.encode(query_text[:1000]).tolist()
+                result = self.collection.query(
+                    query_embeddings=[query_embedding],
+                    n_results=n_results,
+                    include=["metadatas", "documents", "distances"]
+                )
+            else:
+                result = self.collection.query(
+                    query_texts=[query_text],
+                    n_results=n_results,
+                    include=["metadatas", "documents", "distances"]
+                )
+            items = []
+            metadatas = result.get("metadatas", [[]])[0]
+            documents = result.get("documents", [[]])[0]
+            distances = result.get("distances", [[]])[0]
+            for i, meta in enumerate(metadatas):
+                item = {
+                    "pblancId": safe_str(meta.get("pblancId")),
+                    "title": safe_str(meta.get("title")),
+                    "content_preview": documents[i][:500] if i < len(documents) else "",
+                    "similarity_score": 1 - (distances[i] if i < len(distances) else 0),
+                }
+                if meta.get("eligibility"):
+                    try:
+                        item["eligibility"] = json.loads(meta["eligibility"])
+                    except:
+                        pass
+                if meta.get("support_details"):
+                    try:
+                        item["support_details"] = json.loads(meta["support_details"])
+                    except:
+                        pass
+                items.append(item)
+            return items
+        except Exception as e:
+            logger.error(f"Vector search error: {e}")
+            return []
+    def get_status(self) -> Dict:
+        """인덱싱 상태 반환"""
+        return {
+            "total_indexed": self.get_indexed_count(),
+            "last_index_time": self.index_status.get("last_index_time"),
+            "in_progress": self.index_status.get("in_progress", False),
+            "progress_current": self.index_status.get("progress_current", 0),
+            "progress_total": self.index_status.get("progress_total", 0),
+            "failed_count": len(self.index_status.get("failed_ids", []))
+        }
 _cache_instance = None
-
-
+_content_cache_instance = None
 def get_cache() -> AnnouncementCache:
-    """싱글톤 캐시 인스턴스 반환"""
+    """메타 캐시 싱글톤"""
     global _cache_instance
     if _cache_instance is None:
         _cache_instance = AnnouncementCache()
     return _cache_instance
-
-
-# ============================================================
-# 동기화 함수
-# ============================================================
+def get_content_cache() -> ContentVectorCache:
+    """본문 벡터 캐시 싱글톤"""
+    global _content_cache_instance
+    if _content_cache_instance is None:
+        _content_cache_instance = ContentVectorCache()
+    return _content_cache_instance
+_indexing_thread = None
+_indexing_stop_flag = False
+def background_content_indexer():
+    """백그라운드 본문 인덱싱 (서비스 무중단)"""
+    global _indexing_stop_flag
+    from file_api import download_file, extract_text_from_file
+    content_cache = get_content_cache()
+    meta_cache = get_cache()
+    if content_cache.index_status.get("in_progress"):
+        logger.info("Content indexing already in progress")
+        return
+    content_cache.index_status["in_progress"] = True
+    content_cache._save_index_status()
+    try:
+        all_items = meta_cache.get_all()
+        indexed_ids = content_cache.get_indexed_ids()
+        items_to_index = []
+        for item in all_items:
+            pblanc_id = safe_str(item.get("pblancId") or item.get("seq"))
+            print_url = safe_str(item.get("printFlpthNm"))
+            print_name = safe_str(item.get("printFileNm"))
+            if pblanc_id and print_url and print_name:
+                if pblanc_id not in indexed_ids:
+                    items_to_index.append({
+                        "pblancId": pblanc_id,
+                        "title": safe_str(item.get("title") or item.get("pblancNm")),
+                        "print_url": print_url,
+                        "print_name": print_name
+                    })
+        total = len(items_to_index)
+        content_cache.index_status["progress_total"] = total
+        content_cache.index_status["progress_current"] = 0
+        content_cache._save_index_status()
+        logger.info(f"Starting background content indexing: {total} items to process")
+        for i, item in enumerate(items_to_index):
+            if _indexing_stop_flag:
+                logger.info("Content indexing stopped by flag")
+                break
+            pblanc_id = item["pblancId"]
+            title = item["title"]
+            print_url = item["print_url"]
+            print_name = item["print_name"]
+            try:
+                with tempfile.TemporaryDirectory() as tmp_dir:
+                    file_path, error = download_file(print_url, tmp_dir, print_name)
+                    if error or not file_path:
+                        logger.warning(f"Download failed for {pblanc_id}: {error}")
+                        content_cache.index_status.setdefault("failed_ids", []).append(pblanc_id)
+                        continue
+                    text, err = extract_text_from_file(file_path)
+                    if not text or len(text) < 100:
+                        logger.warning(f"Text extraction failed for {pblanc_id}: {err}")
+                        content_cache.index_status.setdefault("failed_ids", []).append(pblanc_id)
+                        continue
+                    success = content_cache.add_content(pblanc_id, title, text)
+                    if success:
+                        logger.info(f"Indexed [{i+1}/{total}]: {title[:30]}...")
+                    else:
+                        logger.warning(f"Failed to add content for {pblanc_id}")
+            except Exception as e:
+                logger.error(f"Error indexing {pblanc_id}: {e}")
+                content_cache.index_status.setdefault("failed_ids", []).append(pblanc_id)
+            content_cache.index_status["progress_current"] = i + 1
+            if (i + 1) % 10 == 0:
+                content_cache._save_index_status()
+            time.sleep(0.5)
+        logger.info(f"Content indexing complete: {content_cache.get_indexed_count()} total indexed")
+    except Exception as e:
+        logger.error(f"Background indexing error: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
+    finally:
+        content_cache.index_status["in_progress"] = False
+        content_cache._save_index_status()
+def start_background_indexing():
+    """백그라운드 인덱싱 시작 (비동기)"""
+    global _indexing_thread, _indexing_stop_flag
+    if _indexing_thread and _indexing_thread.is_alive():
+        logger.info("Background indexing already running")
+        return False
+    _indexing_stop_flag = False
+    _indexing_thread = threading.Thread(target=background_content_indexer, daemon=True)
+    _indexing_thread.start()
+    logger.info("Background content indexing thread started")
+    return True
+def stop_background_indexing():
+    """���그라운드 인덱싱 중지"""
+    global _indexing_stop_flag
+    _indexing_stop_flag = True
+    logger.info("Background indexing stop requested")
 def sync_from_api() -> Tuple[int, int, str]:
-    """
-    API에서 공고를 가져와 캐시에 동기화
-    Returns: (added_count, updated_count, status_message)
-    """
+    """API에서 공고를 가져와 캐시에 동기화"""
     from file_api import fetch_all_from_api
-    
     cache = get_cache()
     sync_time = datetime.now(KST)
-    
     logger.info(f"Starting sync at {sync_time.strftime('%Y-%m-%d %H:%M:%S')} KST")
-    
     try:
-        # API에서 전체 데이터 가져오기
         items, error = fetch_all_from_api(category="전체", region="전체(지역)", keyword="")
-        
         if error and not items:
             msg = f"❌ API 오류: {error}"
             logger.error(msg)
             return 0, 0, msg
-        
         if not items:
             msg = "⚠️ API에서 데이터를 가져올 수 없습니다."
             logger.warning(msg)
             return 0, 0, msg
-        
-        # 캐시에 저장
         added, updated = cache.bulk_upsert(items)
-        
-        # 동기화 이력 저장
         sync_record = {
             "timestamp": sync_time.isoformat(),
             "api_count": len(items),
@@ -411,49 +623,38 @@ def sync_from_api() -> Tuple[int, int, str]:
             "updated": updated,
             "total_cached": cache.get_count()
         }
-        
         cache.metadata.setdefault("sync_history", []).append(sync_record)
-        # 최근 100개 이력만 유지
         cache.metadata["sync_history"] = cache.metadata["sync_history"][-100:]
         cache._save_metadata()
-        
         msg = f"✅ 동기화 완료: API {len(items)}건 → 신규 {added}건, 업데이트 {updated}건 (총 {cache.get_count()}건)"
         logger.info(msg)
+        if added > 0:
+            start_background_indexing()
         return added, updated, msg
-        
     except Exception as e:
         import traceback
         logger.error(f"Sync error: {e}")
         logger.error(traceback.format_exc())
         msg = f"❌ 동기화 오류: {str(e)}"
         return 0, 0, msg
-
-
 def get_cached_announcements() -> Tuple[List[Dict], str]:
-    """
-    캐시에서 공고 목록 반환 (캐시가 비어있으면 API에서 로드)
-    Returns: (items, status_message)
-    """
+    """캐시에서 공고 목록 반환"""
     cache = get_cache()
     count = cache.get_count()
-    
     if count == 0:
-        # 초기 로드
         logger.info("Cache empty, performing initial sync...")
         added, updated, msg = sync_from_api()
         if added == 0 and updated == 0:
             return [], msg
-    
     items = cache.get_all()
     last_sync = cache.metadata.get("last_sync", "알 수 없음")
-    
     status = f"📦 캐시에서 {len(items)}건 로드 (마지막 동기화: {last_sync})"
     return items, status
-
-
 def get_sync_status() -> Dict:
     """동기화 상태 정보 반환"""
     cache = get_cache()
+    content_cache = get_content_cache()
+    content_status = content_cache.get_status()
     return {
         "total_count": cache.get_count(),
         "last_sync": cache.metadata.get("last_sync"),
@@ -461,31 +662,24 @@ def get_sync_status() -> Dict:
         "db_path": str(DB_PATH),
         "chromadb_available": CHROMADB_AVAILABLE,
         "scheduler_available": SCHEDULER_AVAILABLE,
+        "content_indexed": content_status["total_indexed"],
+        "content_indexing_in_progress": content_status["in_progress"],
+        "content_progress": f"{content_status['progress_current']}/{content_status['progress_total']}",
+        "content_failed_count": content_status["failed_count"],
+        "embedding_available": EMBEDDING_AVAILABLE,
     }
-
-
-# ============================================================
-# 스케줄러
-# ============================================================
 _scheduler = None
-
-
 def start_scheduler():
     """백그라운드 스케줄러 시작 (KST 10:00, 22:00)"""
     global _scheduler
-    
     if not SCHEDULER_AVAILABLE:
         logger.warning("Scheduler not available")
         return False
-    
     if _scheduler is not None:
         logger.info("Scheduler already running")
         return True
-    
     try:
         _scheduler = BackgroundScheduler(timezone=KST)
-        
-        # 매일 오전 10시 (KST)
         _scheduler.add_job(
             sync_from_api,
             CronTrigger(hour=10, minute=0, timezone=KST),
@@ -493,8 +687,6 @@ def start_scheduler():
             name='Daily sync at 10:00 KST',
             replace_existing=True
         )
-        
-        # 매일 오후 10시 (KST)
         _scheduler.add_job(
             sync_from_api,
             CronTrigger(hour=22, minute=0, timezone=KST),
@@ -502,16 +694,12 @@ def start_scheduler():
             name='Daily sync at 22:00 KST',
             replace_existing=True
         )
-        
         _scheduler.start()
         logger.info("Scheduler started: sync at 10:00 and 22:00 KST")
         return True
-        
     except Exception as e:
         logger.error(f"Scheduler start error: {e}")
         return False
-
-
 def stop_scheduler():
     """스케줄러 중지"""
     global _scheduler
@@ -519,39 +707,27 @@ def stop_scheduler():
         _scheduler.shutdown()
         _scheduler = None
         logger.info("Scheduler stopped")
-
-
 def manual_sync() -> str:
     """수동 동기화 실행"""
     added, updated, msg = sync_from_api()
     return msg
-
-
-# ============================================================
-# 앱 시작 시 초기화
-# ============================================================
 def initialize_cache_system():
     """캐시 시스템 초기화 (앱 시작 시 호출)"""
     logger.info("Initializing cache system...")
-    
-    # 캐시 초기화
     cache = get_cache()
     count = cache.get_count()
-    
     if count == 0:
         logger.info("Cache is empty, performing initial sync...")
         sync_from_api()
     else:
         logger.info(f"Cache loaded with {count} announcements")
-    
-    # 스케줄러 시작
+    content_cache = get_content_cache()
+    content_count = content_cache.get_indexed_count()
+    logger.info(f"Content cache: {content_count} indexed")
     start_scheduler()
-    
+    start_background_indexing()
     return get_sync_status()
-
-
 if __name__ == "__main__":
-    # 테스트
     print("Testing cache system...")
     status = initialize_cache_system()
     print(f"Status: {json.dumps(status, ensure_ascii=False, indent=2)}")