Update app.py

app.py

@@ -44,6 +44,9 @@ pdf_cache: Dict[str, Dict[str, Any]] = {}
 cache_locks = {}
 pdf_embeddings: Dict[str, Dict[str, Any]] = {}
 
+# VLM 분석 상태 추적 (메모리)
+analysis_status: Dict[str, Dict[str, Any]] = {}
+
 
 def get_cache_path(pdf_name: str):
     return CACHE_DIR / f"{pdf_name}_cache.json"
@@ -102,18 +105,18 @@ def get_pdf_page_as_base64(pdf_path: str, page_num: int, scale: float = 1.0) ->
         return None
 
 
-def get_pdf_pages_as_base64(pdf_path: str, max_pages: int = 25, scale: float = 0.8) -> List[Dict[str, Any]]:
-    """PDF 여러 페이지를 base64 이미지 리스트로 변환 (기본 25페이지)"""
+def get_pdf_pages_as_base64(pdf_path: str, start_page: int = 0, max_pages: int = 10, scale: float = 0.7) -> List[Dict[str, Any]]:
+    """PDF 여러 페이지를 base64 이미지 리스트로 변환 (배치 처리용)"""
     try:
         doc = fitz.open(pdf_path)
         total_pages = doc.page_count
-        pages_to_process = min(total_pages, max_pages)
+        end_page = min(start_page + max_pages, total_pages)
         
         images = []
-        for page_num in range(pages_to_process):
+        for page_num in range(start_page, end_page):
             page = doc[page_num]
             pix = page.get_pixmap(matrix=fitz.Matrix(scale, scale))
-            img_data = pix.tobytes("jpeg", 80)
+            img_data = pix.tobytes("jpeg", 75)
             b64_img = base64.b64encode(img_data).decode('utf-8')
             images.append({
                 "page": page_num + 1,
@@ -121,35 +124,52 @@ def get_pdf_pages_as_base64(pdf_path: str, max_pages: int = 25, scale: float = 0
             })
         
         doc.close()
-        logger.info(f"PDF {pages_to_process}/{total_pages}페이지 이미지 변환 완료")
-        return images
+        logger.info(f"PDF {start_page+1}~{end_page}/{total_pages}페이지 이미지 변환 완료")
+        return images, total_pages
     except Exception as e:
         logger.error(f"PDF 페이지들 이미지 변환 오류: {e}")
-        return []
+        return [], 0
 
 
-async def analyze_pdf_with_vlm(pdf_id: str, force_refresh: bool = False) -> Dict[str, Any]:
-    """VLM으로 PDF 전체 분석 후 캐시에 저장 (25페이지)"""
+def call_fireworks_vlm_api(messages: List[Dict], max_tokens: int = 4096, temperature: float = 0.6) -> str:
+    """Fireworks AI VLM API 호출 (이미지 분석 지원)"""
+    if not HAS_VALID_API_KEY:
+        raise Exception("API 키가 설정되지 않았습니다.")
     
-    # 캐시 확인
-    if not force_refresh:
-        cached = load_analysis_cache(pdf_id)
-        if cached:
-            return cached
+    payload = {
+        "model": FIREWORKS_VLM_MODEL,
+        "max_tokens": max_tokens,
+        "top_p": 1,
+        "top_k": 40,
+        "presence_penalty": 0,
+        "frequency_penalty": 0,
+        "temperature": temperature,
+        "messages": messages
+    }
     
-    pdf_path = str(PROMPT_PDF_PATH)
-    if not PROMPT_PDF_PATH.exists():
-        return {"error": "PDF 파일을 찾을 수 없습니다."}
+    headers = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {FIREWORKS_API_KEY}"
+    }
+    
+    response = requests.post(FIREWORKS_API_URL, headers=headers, data=json.dumps(payload), timeout=180)
     
-    # PDF 페이지들을 이미지로 변환 (최대 25페이지)
-    page_images = get_pdf_pages_as_base64(pdf_path, max_pages=25, scale=0.7)
+    if response.status_code != 200:
+        raise Exception(f"API 오류: {response.status_code} - {response.text}")
+    
+    result = response.json()
+    return result["choices"][0]["message"]["content"]
+
+
+def analyze_batch_pages_sync(pdf_path: str, start_page: int, batch_size: int = 5) -> str:
+    """배치 페이지 분석 (동기)"""
+    page_images, total_pages = get_pdf_pages_as_base64(pdf_path, start_page, batch_size, scale=0.6)
     
     if not page_images:
-        return {"error": "PDF 이미지 변환 실패"}
+        return ""
     
-    # VLM으로 전체 내용 분석
     content_parts = []
-    
     for img_data in page_images:
         content_parts.append({
             "type": "image_url",
@@ -158,85 +178,147 @@ async def analyze_pdf_with_vlm(pdf_id: str, force_refresh: bool = False) -> Dict
             }
         })
     
+    page_range = f"{start_page + 1}~{start_page + len(page_images)}"
     content_parts.append({
         "type": "text",
-        "text": f"""위 이미지들은 PDF 문서의 페이지들입니다 (총 {len(page_images)}페이지).
-
-이 PDF 문서의 전체 내용을 상세하게 분석해주세요.
-
-다음 형식으로 작성해주세요:
-
-## 문서 개요
-- 문서 제목/주제:
-- 문서 유형:
-- 작성 목적:
-
-## 페이지별 핵심 내용
-각 페이지의 주요 내용을 요약해주세요.
+        "text": f"""위 이미지들은 PDF 문서의 {page_range}페이지입니다.
 
-## 전체 요약
-문서의 핵심 내용을 500자 내외로 요약해주세요.
-
-## 주요 키워드
-문서에서 중요한 ��워드나 개념들을 나열해주세요.
-
-## 상세 내용
-문서에 포함된 모든 중요한 정보, 데이터, 표, 그래프 내용 등을 상세히 기술해주세요.
+각 페이지의 내용을 상세하게 분석하여 텍스트로 추출해주세요.
+- 모든 텍스트 내용을 빠짐없이 추출
+- 표, 차트, 그래프가 있으면 내용 설명
+- 이미지가 있으면 설명
+- 페이지별로 구분하여 작성
 
 한국어로 작성해주세요."""
     })
 
     messages = [{"role": "user", "content": content_parts}]
+    
+    return call_fireworks_vlm_api(messages, max_tokens=4096, temperature=0.3)
 
+
+async def analyze_pdf_with_vlm_batched(pdf_id: str, force_refresh: bool = False) -> Dict[str, Any]:
+    """VLM으로 PDF 배치 분석 후 캐시에 저장"""
+    global analysis_status
+    
+    # 이미 분석 중인지 확인
+    if pdf_id in analysis_status and analysis_status[pdf_id].get("status") == "analyzing":
+        logger.info(f"PDF {pdf_id} 이미 분석 중...")
+        return {"status": "analyzing", "progress": analysis_status[pdf_id].get("progress", 0)}
+    
+    # 캐시 확인
+    if not force_refresh:
+        cached = load_analysis_cache(pdf_id)
+        if cached:
+            analysis_status[pdf_id] = {"status": "completed", "progress": 100}
+            return cached
+    
+    pdf_path = str(PROMPT_PDF_PATH)
+    if not PROMPT_PDF_PATH.exists():
+        analysis_status[pdf_id] = {"status": "error", "error": "PDF 파일 없음"}
+        return {"error": "PDF 파일을 찾을 수 없습니다."}
+    
+    if not HAS_VALID_API_KEY:
+        analysis_status[pdf_id] = {"status": "error", "error": "API 키 없음"}
+        return {"error": "API 키가 설정되지 않았습니다."}
+    
+    # 분석 시작
+    analysis_status[pdf_id] = {"status": "analyzing", "progress": 0, "started_at": time.time()}
+    
     try:
-        logger.info(f"VLM PDF 분석 시작: {len(page_images)}페이지")
-        analysis_text = call_fireworks_vlm_api(messages, max_tokens=8192, temperature=0.3)
+        # PDF 총 페이지 수 확인
+        doc = fitz.open(pdf_path)
+        total_pages = doc.page_count
+        doc.close()
+        
+        logger.info(f"PDF 분석 시작: 총 {total_pages}페이지")
+        
+        # 배치로 나눠서 분석 (5페이지씩)
+        batch_size = 5
+        all_analyses = []
+        
+        for start_page in range(0, min(total_pages, 25), batch_size):  # 최대 25페이지
+            try:
+                progress = int((start_page / min(total_pages, 25)) * 100)
+                analysis_status[pdf_id]["progress"] = progress
+                logger.info(f"배치 분석 중: {start_page + 1}페이지부터 (진행률: {progress}%)")
+                
+                # 동기 함수를 별도 스레드에서 실행
+                loop = asyncio.get_event_loop()
+                batch_result = await loop.run_in_executor(
+                    None, 
+                    analyze_batch_pages_sync, 
+                    pdf_path, 
+                    start_page, 
+                    batch_size
+                )
+                
+                if batch_result:
+                    all_analyses.append(f"### 페이지 {start_page + 1}~{min(start_page + batch_size, total_pages)}\n{batch_result}")
+                
+                # API 레이트 리밋 방지
+                await asyncio.sleep(2)
+                
+            except Exception as batch_error:
+                logger.error(f"배치 {start_page} 분석 오류: {batch_error}")
+                all_analyses.append(f"### 페이지 {start_page + 1}~{min(start_page + batch_size, total_pages)}\n[분석 실패: {str(batch_error)}]")
+        
+        # 전체 분석 결과 합치기
+        combined_analysis = "\n\n".join(all_analyses)
+        
+        # 요약 생성
+        summary = ""
+        if combined_analysis:
+            try:
+                summary_messages = [
+                    {
+                        "role": "system",
+                        "content": "다음 PDF 분석 내용을 500자 이내로 요약해주세요. 핵심 내용과 주요 키워드를 포함해주세요."
+                    },
+                    {
+                        "role": "user",
+                        "content": combined_analysis[:8000]  # 토큰 제한
+                    }
+                ]
+                summary = call_fireworks_vlm_api(summary_messages, max_tokens=1024, temperature=0.5)
+            except Exception as sum_err:
+                logger.error(f"요약 생성 오류: {sum_err}")
+                summary = combined_analysis[:500] + "..."
         
         analysis_data = {
             "pdf_id": pdf_id,
-            "total_pages": len(page_images),
-            "analysis": analysis_text,
+            "total_pages": total_pages,
+            "analyzed_pages": min(total_pages, 25),
+            "analysis": combined_analysis,
+            "summary": summary,
             "created_at": time.time()
         }
         
         # 캐시에 저장
         save_analysis_cache(pdf_id, analysis_data)
         
+        analysis_status[pdf_id] = {"status": "completed", "progress": 100}
+        logger.info(f"PDF 분석 완료: {pdf_id}")
+        
         return analysis_data
+        
     except Exception as e:
         logger.error(f"VLM PDF 분석 오류: {e}")
+        analysis_status[pdf_id] = {"status": "error", "error": str(e)}
         return {"error": str(e)}
 
 
-def call_fireworks_vlm_api(messages: List[Dict], max_tokens: int = 4096, temperature: float = 0.6) -> str:
-    """Fireworks AI VLM API 호출 (이미지 분석 지원)"""
-    if not HAS_VALID_API_KEY:
-        raise Exception("API 키가 설정되지 않았습니다.")
-    
-    payload = {
-        "model": FIREWORKS_VLM_MODEL,
-        "max_tokens": max_tokens,
-        "top_p": 1,
-        "top_k": 40,
-        "presence_penalty": 0,
-        "frequency_penalty": 0,
-        "temperature": temperature,
-        "messages": messages
-    }
-    
-    headers = {
-        "Accept": "application/json",
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {FIREWORKS_API_KEY}"
-    }
-    
-    response = requests.post(FIREWORKS_API_URL, headers=headers, data=json.dumps(payload), timeout=120)
-    
-    if response.status_code != 200:
-        raise Exception(f"API 오류: {response.status_code} - {response.text}")
-    
-    result = response.json()
-    return result["choices"][0]["message"]["content"]
+async def run_initial_analysis():
+    """서버 시작 시 초기 분석 실행"""
+    logger.info("초기 PDF 분석 시작...")
+    try:
+        result = await analyze_pdf_with_vlm_batched(PROMPT_PDF_ID)
+        if "error" in result:
+            logger.error(f"초기 분석 실패: {result['error']}")
+        else:
+            logger.info("초기 PDF 분석 완료!")
+    except Exception as e:
+        logger.error(f"초기 분석 예외: {e}")
 
 
 def extract_pdf_text(pdf_path: str) -> List[Dict[str, Any]]:
@@ -245,18 +327,15 @@ def extract_pdf_text(pdf_path: str) -> List[Dict[str, Any]]:
         chunks = []
         for page_num in range(len(doc)):
             page = doc[page_num]
-            # 여러 방법으로 텍스트 추출 시도
             text = page.get_text("text")
             
-            # 텍스트가 없으면 다른 방법 시도
             if not text.strip():
                 text = page.get_text("blocks")
                 if text:
                     text = "\n".join([block[4] for block in text if len(block) > 4 and isinstance(block[4], str)])
             
-            # 여전히 텍스트가 없으면 페이지 정보만이라도 추가
             if not text.strip():
-                text = f"[페이지 {page_num + 1} - 이미지 또는 텍스트 없음]"
+                text = f"[페이지 {page_num + 1} - 이미지 기반 페이지]"
             
             chunks.append({
                 "page": page_num + 1,
@@ -271,54 +350,6 @@ def extract_pdf_text(pdf_path: str) -> List[Dict[str, Any]]:
         return []
 
 
-async def get_pdf_embedding(pdf_id: str) -> Dict[str, Any]:
-    try:
-        embedding_path = get_embedding_path(pdf_id)
-        if embedding_path.exists():
-            try:
-                with open(embedding_path, "r", encoding="utf-8") as f:
-                    return json.load(f)
-            except Exception as e:
-                logger.error(f"임베딩 캐시 로드 오류: {e}")
-
-        pdf_path = str(PROMPT_PDF_PATH)
-        if not PROMPT_PDF_PATH.exists():
-            raise ValueError(f"PDF 파일을 찾을 수 없습니다: {pdf_path}")
-
-        chunks = extract_pdf_text(pdf_path)
-        
-        # 텍스트 추출 실패해도 기본 정보 제공
-        if not chunks:
-            logger.warning(f"PDF에서 텍스트를 추출할 수 없습니다. 기본 정보로 대체합니다.")
-            try:
-                doc = fitz.open(pdf_path)
-                total_pages = doc.page_count
-                doc.close()
-                chunks = [{"page": i+1, "text": f"[페이지 {i+1}]", "chunk_id": f"page_{i+1}"} for i in range(total_pages)]
-            except:
-                chunks = [{"page": 1, "text": "[PDF 내용을 읽을 수 없습니다]", "chunk_id": "page_1"}]
-
-        embedding_data = {
-            "pdf_id": pdf_id,
-            "pdf_path": pdf_path,
-            "chunks": chunks,
-            "created_at": time.time()
-        }
-
-        with open(embedding_path, "w", encoding="utf-8") as f:
-            json.dump(embedding_data, f, ensure_ascii=False)
-
-        return embedding_data
-    except Exception as e:
-        logger.error(f"PDF 임베딩 생성 오류: {e}")
-        return {"error": str(e), "pdf_id": pdf_id, "chunks": []}
-
-
-def call_fireworks_api(messages: List[Dict], max_tokens: int = 4096, temperature: float = 0.6) -> str:
-    """Fireworks AI VLM API 호출"""
-    return call_fireworks_vlm_api(messages, max_tokens, temperature)
-
-
 async def query_pdf(pdf_id: str, query: str) -> Dict[str, Any]:
     """캐시된 VLM 분석 결과�� 기반으로 질의응답"""
     try:
@@ -329,10 +360,18 @@ async def query_pdf(pdf_id: str, query: str) -> Dict[str, Any]:
             }
 
         # 캐시된 분석 결과 확인
-        analysis_data = await analyze_pdf_with_vlm(pdf_id)
+        analysis_data = load_analysis_cache(pdf_id)
         
-        if "error" in analysis_data:
-            return {"error": analysis_data["error"], "answer": "PDF 분석에 실패했습니다."}
+        if not analysis_data:
+            # 분석 상태 확인
+            if pdf_id in analysis_status:
+                status = analysis_status[pdf_id].get("status")
+                if status == "analyzing":
+                    progress = analysis_status[pdf_id].get("progress", 0)
+                    return {"error": f"분석 진행 중 ({progress}%)", "answer": f"PDF 분석이 진행 중입니다 ({progress}%). 잠시만 기다려주세요."}
+                elif status == "error":
+                    return {"error": "분석 실패", "answer": f"PDF 분석에 실패했습니다: {analysis_status[pdf_id].get('error', '알 수 없는 오류')}"}
+            return {"error": "분석 데이터 없음", "answer": "PDF가 아직 분석되지 않았습니다. 잠시 후 다시 시도해주세요."}
         
         analysis_text = analysis_data.get("analysis", "")
         total_pages = analysis_data.get("total_pages", 0)
@@ -351,7 +390,7 @@ async def query_pdf(pdf_id: str, query: str) -> Dict[str, Any]:
 분석 내용에 없는 정보는 "해당 정보를 찾을 수 없습니다"라고 솔직히 답해주세요.
 
 === PDF 분석 결과 ===
-{analysis_text}
+{analysis_text[:12000]}
 =================="""
             },
             {
@@ -361,32 +400,17 @@ async def query_pdf(pdf_id: str, query: str) -> Dict[str, Any]:
         ]
 
         try:
-            for attempt in range(3):
-                try:
-                    answer = call_fireworks_vlm_api(messages, max_tokens=4096, temperature=0.6)
-                    return {
-                        "answer": answer,
-                        "pdf_id": pdf_id,
-                        "query": query
-                    }
-                except Exception as api_error:
-                    logger.error(f"Fireworks API 호출 오류 (시도 {attempt+1}/3): {api_error}")
-                    if attempt == 2:
-                        raise api_error
-                    await asyncio.sleep(2 * (attempt + 1))
-
-            raise Exception("API 호출 재시도 모두 실패")
+            answer = call_fireworks_vlm_api(messages, max_tokens=4096, temperature=0.6)
+            return {
+                "answer": answer,
+                "pdf_id": pdf_id,
+                "query": query
+            }
         except Exception as api_error:
-            logger.error(f"Fireworks API 호출 최종 오류: {api_error}")
+            logger.error(f"Fireworks API 호출 오류: {api_error}")
             error_message = str(api_error)
-            if "Connection" in error_message:
-                return {"error": "AI 서버와 연결할 수 없습니다.", "answer": "네트워크 연결을 확인해주세요."}
-            elif "401" in error_message or "Unauthorized" in error_message:
-                return {"error": "API 키가 유효하지 않습니다.", "answer": "API 인증에 실패했습니다."}
-            elif "429" in error_message or "Rate limit" in error_message:
-                return {"error": "API 호출 한도 초과", "answer": "잠시 후 다시 시도해주세요."}
-            else:
-                return {"error": f"AI 오류: {error_message}", "answer": "처리 중 오류가 발생했습니다."}
+            return {"error": f"AI 오류: {error_message}", "answer": "처리 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요."}
+            
     except Exception as e:
         logger.error(f"질의응답 처리 오류: {e}")
         return {"error": str(e), "answer": "처리 중 오류가 발생했습니다."}
@@ -401,51 +425,42 @@ async def summarize_pdf(pdf_id: str) -> Dict[str, Any]:
                 "summary": "API 키가 없어 요약을 생성할 수 없습니다."
             }
 
-        # 캐시된 분석 결과 확인 (없으면 새로 분석)
-        analysis_data = await analyze_pdf_with_vlm(pdf_id)
+        # 캐시된 분석 결과 확인
+        analysis_data = load_analysis_cache(pdf_id)
         
-        if "error" in analysis_data:
-            return {"error": analysis_data["error"], "summary": "PDF 분석에 실패했습니다."}
+        if not analysis_data:
+            # 분석 상태 확인
+            if pdf_id in analysis_status:
+                status = analysis_status[pdf_id].get("status")
+                if status == "analyzing":
+                    progress = analysis_status[pdf_id].get("progress", 0)
+                    return {"error": f"분석 진행 중", "summary": f"PDF 분석이 진행 중입니다 ({progress}%). 잠시만 기다려주세요."}
+                elif status == "error":
+                    return {"error": "분석 실패", "summary": f"PDF 분석에 실패했습니다."}
+            return {"error": "분석 데이터 없음", "summary": "PDF가 아직 분석되지 않았습니다."}
         
-        analysis_text = analysis_data.get("analysis", "")
+        summary = analysis_data.get("summary", "")
         total_pages = analysis_data.get("total_pages", 0)
+        analyzed_pages = analysis_data.get("analyzed_pages", total_pages)
         
-        if not analysis_text:
-            return {"error": "분석 데이터 없음", "summary": "PDF 분석 데이터를 찾을 수 없습니다."}
-
-        # 분석 결과에서 요약 부분 추출 또는 새로 요약 생성
-        messages = [
-            {
-                "role": "system",
-                "content": """아래는 PDF 문서를 VLM으로 분석한 결과입니다.
-이 분석 내용을 바탕으로 사용자에게 문서를 소개하는 친절한 요약을 작성해주세요.
-500자 이내로 핵심 내용을 간결하게 한국어로 요약해주세요."""
-            },
-            {
-                "role": "user",
-                "content": f"다음 PDF 분석 결과를 요약해주세요:\n\n{analysis_text}"
-            }
-        ]
-
-        try:
-            summary = call_fireworks_vlm_api(messages, max_tokens=1024, temperature=0.5)
+        if summary:
             return {
                 "summary": summary,
                 "pdf_id": pdf_id,
+                "total_pages": total_pages,
+                "analyzed_pages": analyzed_pages
+            }
+        
+        # 요약이 없으면 분석 내용에서 추출
+        analysis_text = analysis_data.get("analysis", "")
+        if analysis_text:
+            return {
+                "summary": analysis_text[:500] + "...",
+                "pdf_id": pdf_id,
                 "total_pages": total_pages
             }
-        except Exception as api_error:
-            logger.error(f"요약 생성 오류: {api_error}")
-            # 캐시된 분석 결과에서 직접 요약 부분 추출 시도
-            if "## 전체 요약" in analysis_text:
-                try:
-                    start = analysis_text.index("## 전체 요약")
-                    end = analysis_text.index("##", start + 10) if "##" in analysis_text[start+10:] else len(analysis_text)
-                    summary_part = analysis_text[start:end].replace("## 전체 요약", "").strip()
-                    return {"summary": summary_part, "pdf_id": pdf_id, "total_pages": total_pages}
-                except:
-                    pass
-            return {"error": str(api_error), "summary": "요약 생성 중 오류가 발생했습니다."}
+        
+        return {"error": "요약 없음", "summary": "요약을 생성할 수 없습니다."}
             
     except Exception as e:
         logger.error(f"PDF 요약 생성 오류: {e}")
@@ -572,9 +587,10 @@ async def cache_pdf(pdf_path: str):
 async def startup_event():
     if PROMPT_PDF_PATH.exists():
         logger.info(f"prompt.pdf 파일 발견: {PROMPT_PDF_PATH}")
+        # 플립북 캐싱
         asyncio.create_task(cache_pdf(str(PROMPT_PDF_PATH)))
-        # VLM 분석도 백그라운드에서 시작
-        asyncio.create_task(analyze_pdf_with_vlm(PROMPT_PDF_ID))
+        # VLM 분석 - 에러 핸들링 포함
+        asyncio.create_task(run_initial_analysis())
     else:
         logger.warning(f"prompt.pdf 파일을 찾을 수 없습니다: {PROMPT_PDF_PATH}")
 
@@ -602,15 +618,27 @@ async def get_pdf_info():
 
 @app.get("/api/analysis-status")
 async def get_analysis_status():
-    """VLM 분석 캐시 상태 확인"""
+    """VLM 분석 상태 확인"""
+    # 먼저 캐시 파일 확인
     cached = load_analysis_cache(PROMPT_PDF_ID)
     if cached:
         return {
             "status": "completed",
             "total_pages": cached.get("total_pages", 0),
+            "analyzed_pages": cached.get("analyzed_pages", 0),
             "created_at": cached.get("created_at", 0)
         }
-    return {"status": "not_analyzed"}
+    
+    # 메모리 상태 확인
+    if PROMPT_PDF_ID in analysis_status:
+        status_info = analysis_status[PROMPT_PDF_ID]
+        return {
+            "status": status_info.get("status", "unknown"),
+            "progress": status_info.get("progress", 0),
+            "error": status_info.get("error")
+        }
+    
+    return {"status": "not_started"}
 
 
 @app.post("/api/reanalyze-pdf")
@@ -626,8 +654,12 @@ async def reanalyze_pdf():
             cache_path.unlink()
             logger.info("기존 VLM 분석 캐시 삭제")
         
+        # 상태 초기화
+        if PROMPT_PDF_ID in analysis_status:
+            del analysis_status[PROMPT_PDF_ID]
+        
         # 백그라운드에서 재분석 시작
-        asyncio.create_task(analyze_pdf_with_vlm(PROMPT_PDF_ID, force_refresh=True))
+        asyncio.create_task(run_initial_analysis())
         
         return {"status": "started", "message": "PDF 재분석을 시작합니다."}
     except Exception as e:
@@ -679,11 +711,10 @@ async def api_query_pdf(query: Dict[str, str]):
             return JSONResponse(content={"error": "PDF 파일을 찾을 수 없습니다"}, status_code=404)
 
         result = await query_pdf(PROMPT_PDF_ID, user_query)
-        # 에러가 있어도 answer가 있으면 정상 응답으로 처리
         if "answer" in result:
             return result
         if "error" in result:
-            return JSONResponse(content=result, status_code=200)  # 에러 메시지도 정상 응답으로
+            return JSONResponse(content=result, status_code=200)
         return result
     except Exception as e:
         logger.error(f"질의응답 API 오류: {e}")
@@ -697,11 +728,10 @@ async def api_summarize_pdf():
             return JSONResponse(content={"error": "PDF 파일을 찾을 수 없습니다"}, status_code=404)
 
         result = await summarize_pdf(PROMPT_PDF_ID)
-        # 에러가 있어도 summary가 있으면 정상 응답으로 처리
         if "summary" in result:
             return result
         if "error" in result:
-            return JSONResponse(content=result, status_code=200)  # 에러 메시지도 정상 응답으로
+            return JSONResponse(content=result, status_code=200)
         return result
     except Exception as e:
         logger.error(f"PDF 요약 API 오류: {e}")
@@ -1325,6 +1355,7 @@ HTML = """
     let isAiChatActive = false;
     let isAiProcessing = false;
     let hasLoadedSummary = false;
+    let analysisCheckInterval = null;
 
     function $id(id) { return document.getElementById(id); }
 
@@ -1411,6 +1442,17 @@ HTML = """
       }
     }
 
+    async function checkAnalysisStatus() {
+      try {
+        const response = await fetch('/api/analysis-status');
+        const data = await response.json();
+        return data;
+      } catch (e) {
+        console.error("분석 상태 확인 오류:", e);
+        return { status: "error" };
+      }
+    }
+
     async function loadPdfSummary() {
       if (isAiProcessing || hasLoadedSummary) return;
       
@@ -1418,65 +1460,93 @@ HTML = """
         isAiProcessing = true;
         addTypingIndicator();
         
-        // 먼저 분석 상태 확인
-        const statusResponse = await fetch('/api/analysis-status');
-        const statusData = await statusResponse.json();
+        // 분석 상태 확인
+        const statusData = await checkAnalysisStatus();
         
-        if (statusData.status !== 'completed') {
+        if (statusData.status === 'analyzing') {
           removeTypingIndicator();
-          addChatMessage(`안녕하세요! 현재 PDF를 AI가 분석하고 있습니다. 📊<br><br>잠시만 기다려주시면 분석이 완료된 후 질문에 답변할 수 있습니다.<br><small style="color:#999;">분석에는 약 1~2분 정도 소요될 수 있습니다.</small>`);
+          const progress = statusData.progress || 0;
+          addChatMessage(`안녕하세요! 현재 PDF를 AI가 분석하고 있습니다. 📊<br><br>진행률: <strong>${progress}%</strong><br><small style="color:#999;">분석이 완료되면 자동으로 알려드리겠습니다.</small>`);
           hasLoadedSummary = true;
           isAiProcessing = false;
           
-          // 분석 완료될 때까지 폴링
-          pollAnalysisStatus();
+          // 분석 완료 폴링
+          startAnalysisPolling();
+          return;
+        }
+        
+        if (statusData.status === 'error') {
+          removeTypingIndicator();
+          addChatMessage(`안녕하세요! PDF 분석 중 오류가 발생했습니다. ⚠️<br><br><small style="color:#e74c3c;">${statusData.error || '알 수 없는 오류'}</small><br><br>페이지를 새로고침하거나 잠시 후 다시 시도해주세요.`);
+          hasLoadedSummary = true;
+          isAiProcessing = false;
           return;
         }
         
+        if (statusData.status === 'not_started') {
+          removeTypingIndicator();
+          addChatMessage(`안녕하세요! PDF 분석이 아직 시작되지 않았습니다. 🔄<br><br><small style="color:#999;">잠시만 기다려주세요...</small>`);
+          hasLoadedSummary = true;
+          isAiProcessing = false;
+          startAnalysisPolling();
+          return;
+        }
+        
+        // 분석 완료됨 - 요약 가져오기
         const response = await fetch('/api/ai/summarize-pdf');
         const data = await response.json();
         
         removeTypingIndicator();
         
         if (data.summary) {
-          const pageInfo = data.total_pages ? ` (${data.total_pages}페이지 분석완료)` : '';
+          const pageInfo = data.analyzed_pages ? ` (${data.analyzed_pages}/${data.total_pages}페이지 분석완료)` : '';
           addChatMessage(`안녕하세요! 이 PDF에 대해 무엇이든 질문해주세요.${pageInfo}<br><br><strong>📄 PDF 요약:</strong><br>${data.summary}`);
-          hasLoadedSummary = true;
-        } else if (data.error) {
-          addChatMessage(`안녕하세요! PDF에 대해 궁금한 것을 질문해주세요.<br><br><small style="color:#999;">⚠️ ${data.error}</small>`);
-          hasLoadedSummary = true;
         } else {
           addChatMessage("안녕하세요! PDF에 대해 질문해주세요. 최선을 다해 답변하겠습니다.");
-          hasLoadedSummary = true;
         }
+        hasLoadedSummary = true;
+        
       } catch (error) {
         console.error("PDF 요약 로드 오류:", error);
         removeTypingIndicator();
-        addChatMessage("안녕하세요! PDF에 대해 질문해주세요. 최선을 다해 답변하겠습니다.");
+        addChatMessage("안녕하세요! PDF에 대해 질문해주세요.");
         hasLoadedSummary = true;
       } finally {
         isAiProcessing = false;
       }
     }
     
-    async function pollAnalysisStatus() {
-      // 분석 완료될 때까지 10초마다 확인
-      const checkInterval = setInterval(async () => {
+    function startAnalysisPolling() {
+      if (analysisCheckInterval) return;
+      
+      analysisCheckInterval = setInterval(async () => {
         try {
-          const response = await fetch('/api/analysis-status');
-          const data = await response.json();
+          const data = await checkAnalysisStatus();
           
           if (data.status === 'completed') {
-            clearInterval(checkInterval);
-            addChatMessage(`✅ PDF 분석이 완료되었습니다! (${data.total_pages}페이지)<br>이제 질문해주세요.`);
+            clearInterval(analysisCheckInterval);
+            analysisCheckInterval = null;
+            addChatMessage(`✅ PDF 분석이 완료되었습니다! (${data.analyzed_pages || data.total_pages}페이지)<br>이제 자유롭게 질문해주세요.`);
+          } else if (data.status === 'analyzing') {
+            // 진행률 업데이트 (선택적)
+            console.log(`분석 진행 중: ${data.progress}%`);
+          } else if (data.status === 'error') {
+            clearInterval(analysisCheckInterval);
+            analysisCheckInterval = null;
+            addChatMessage(`⚠️ PDF 분석 실패: ${data.error || '알 수 없는 오류'}`);
           }
         } catch (e) {
-          console.error("분석 상태 확인 오류:", e);
+          console.error("폴링 오류:", e);
         }
-      }, 10000);
+      }, 5000);  // 5초마다 확인
       
       // 5분 후 자동 중지
-      setTimeout(() => clearInterval(checkInterval), 300000);
+      setTimeout(() => {
+        if (analysisCheckInterval) {
+          clearInterval(analysisCheckInterval);
+          analysisCheckInterval = null;
+        }
+      }, 300000);
     }
 
     async function submitQuestion(question) {
@@ -1489,14 +1559,17 @@ HTML = """
         addChatMessage(question, true);
         
         // 분석 상태 확인
-        const statusResponse = await fetch('/api/analysis-status');
-        const statusData = await statusResponse.json();
+        const statusData = await checkAnalysisStatus();
         
         if (statusData.status !== 'completed') {
-          addChatMessage("PDF 분석이 아직 진행 중입니다. 잠시만 기다려주세요... ⏳");
+          if (statusData.status === 'analyzing') {
+            addChatMessage(`PDF 분석이 진행 중입니다 (${statusData.progress || 0}%). 완료 후 질문해주세요. ⏳`);
+          } else {
+            addChatMessage("PDF 분석이 아직 완료되지 않았습니다. 잠시만 기다려주세요.");
+          }
           isAiProcessing = false;
           $id('aiChatSubmit').disabled = false;
-          $id('aiChatInput').value = question; // 질문 유지
+          $id('aiChatInput').value = question;
           return;
         }
         
@@ -1506,7 +1579,7 @@ HTML = """
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ query: question }),
-          signal: AbortSignal.timeout(120000)  // 2분 타임아웃
+          signal: AbortSignal.timeout(120000)
         });
         
         const data = await response.json();
@@ -1551,7 +1624,7 @@ HTML = """
     }
 
     function updateLoading(message, progress) {
-      const text = $id('loadingText');
+      const text = document.querySelector('.loading-text');
       if (text) text.textContent = message;
       const bar = $id('progressBar');
       if (bar && progress !== undefined) bar.style.width = `${progress}%`;
@@ -1681,7 +1754,6 @@ HTML = """
           }
         }
 
-        // 캐시가 없으면 캐싱 시작하고 진행 상황 모니터링
         const cacheResponse = await fetch('/api/cached-pdf');
         let cachedData = await cacheResponse.json();
 
@@ -1691,7 +1763,6 @@ HTML = """
           return;
         }
 
-        // 캐싱 진행 중이면 완료될 때까지 대기
         while (cachedData.status === "processing" || cachedData.status === "started") {
           await new Promise(resolve => setTimeout(resolve, 1000));
           
@@ -1727,11 +1798,9 @@ HTML = """
     document.addEventListener('DOMContentLoaded', function() {
       initializeAudio();
 
-      // AI 버튼 이벤트
       $id('aiButton').addEventListener('click', () => toggleAiChat(!isAiChatActive));
       $id('aiChatClose').addEventListener('click', () => toggleAiChat(false));
 
-      // 채팅 폼 이벤트
       $id('aiChatForm').addEventListener('submit', function(e) {
         e.preventDefault();
         const question = $id('aiChatInput').value.trim();
@@ -1740,7 +1809,6 @@ HTML = """
         }
       });
 
-      // PDF 자동 로드
       loadPDF();
     });
 </script>