Create app-backup.py

app-backup.py

@@ -0,0 +1,1945 @@
+from fastapi import FastAPI, BackgroundTasks, Request
+from fastapi.responses import HTMLResponse, JSONResponse, Response
+from fastapi.staticfiles import StaticFiles
+import pathlib, os, uvicorn, base64, json, uuid, time
+from typing import Dict, List, Any, Optional
+import asyncio
+import logging
+import threading
+import concurrent.futures
+import requests
+import fitz
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+BASE = pathlib.Path(__file__).parent
+app = FastAPI()
+app.mount("/static", StaticFiles(directory=BASE), name="static")
+
+CACHE_DIR = BASE / "cache"
+if not CACHE_DIR.exists():
+    CACHE_DIR.mkdir(parents=True)
+
+EMBEDDING_DIR = BASE / "embeddings"
+if not EMBEDDING_DIR.exists():
+    EMBEDDING_DIR.mkdir(parents=True)
+
+# Fireworks AI API 설정 (VLM 모델)
+FIREWORKS_API_KEY = os.getenv("FIREWORKS_API", "").strip()  # 줄바꿈/공백 제거
+FIREWORKS_API_URL = "https://api.fireworks.ai/inference/v1/chat/completions"
+FIREWORKS_VLM_MODEL = "accounts/fireworks/models/qwen3-vl-235b-a22b-instruct"
+HAS_VALID_API_KEY = bool(FIREWORKS_API_KEY)
+
+if HAS_VALID_API_KEY:
+    logger.info("Fireworks AI VLM API 키 설정 완료")
+else:
+    logger.warning("유효한 Fireworks AI API 키가 없습니다. AI 기능이 제한됩니다.")
+
+# 고정 PDF 파일 경로
+PROMPT_PDF_PATH = BASE / "prompt.pdf"
+PROMPT_PDF_ID = "prompt_pdf_main"
+
+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"
+
+
+def get_embedding_path(pdf_id: str):
+    return EMBEDDING_DIR / f"{pdf_id}_embedding.json"
+
+
+def get_analysis_cache_path(pdf_id: str):
+    """VLM 분석 결과 캐시 경로"""
+    return EMBEDDING_DIR / f"{pdf_id}_vlm_analysis.json"
+
+
+def load_analysis_cache(pdf_id: str) -> Optional[Dict[str, Any]]:
+    """VLM 분석 캐시 로드"""
+    cache_path = get_analysis_cache_path(pdf_id)
+    if cache_path.exists():
+        try:
+            with open(cache_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                logger.info(f"VLM 분석 캐시 로드 완료: {pdf_id}")
+                return data
+        except Exception as e:
+            logger.error(f"분석 캐시 로드 오류: {e}")
+    return None
+
+
+def save_analysis_cache(pdf_id: str, analysis_data: Dict[str, Any]):
+    """VLM 분석 결과 캐시 저장"""
+    cache_path = get_analysis_cache_path(pdf_id)
+    try:
+        with open(cache_path, "w", encoding="utf-8") as f:
+            json.dump(analysis_data, f, ensure_ascii=False, indent=2)
+        logger.info(f"VLM 분석 캐시 저장 완료: {pdf_id}")
+    except Exception as e:
+        logger.error(f"분석 캐시 저장 오류: {e}")
+
+
+def get_pdf_page_as_base64(pdf_path: str, page_num: int, scale: float = 1.0) -> str:
+    """PDF 페이지를 base64 이미지로 변환"""
+    try:
+        doc = fitz.open(pdf_path)
+        if page_num >= doc.page_count:
+            doc.close()
+            return None
+        
+        page = doc[page_num]
+        pix = page.get_pixmap(matrix=fitz.Matrix(scale, scale))
+        img_data = pix.tobytes("jpeg", 85)
+        b64_img = base64.b64encode(img_data).decode('utf-8')
+        doc.close()
+        return b64_img
+    except Exception as e:
+        logger.error(f"PDF 페이지 이미지 변환 오류: {e}")
+        return None
+
+
+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
+        end_page = min(start_page + max_pages, total_pages)
+        
+        images = []
+        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", 75)
+            b64_img = base64.b64encode(img_data).decode('utf-8')
+            images.append({
+                "page": page_num + 1,
+                "image_base64": b64_img
+            })
+        
+        doc.close()
+        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 [], 0
+
+
+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=180)
+    
+    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 ""
+    
+    content_parts = []
+    for img_data in page_images:
+        content_parts.append({
+            "type": "image_url",
+            "image_url": {
+                "url": f"data:image/jpeg;base64,{img_data['image_base64']}"
+            }
+        })
+    
+    page_range = f"{start_page + 1}~{start_page + len(page_images)}"
+    content_parts.append({
+        "type": "text",
+        "text": f"""위 이미지들은 PDF 문서의 {page_range}페이지입니다.
+
+각 페이지의 내용을 상세하게 분석하여 텍스트로 추출해주세요.
+- 모든 텍스트 내용을 빠짐없이 추출
+- 표, 차트, 그래프가 있으면 내용 설명
+- 이미지가 있으면 설명
+- 페이지별로 구분하여 작성
+
+한국어로 작성해주세요."""
+    })
+
+    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:
+        # 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)
+        
+        # 성공한 분석이 있는지 확인
+        successful_analyses = [a for a in all_analyses if "[분석 실패:" not in a]
+        if not successful_analyses:
+            logger.error("모든 배치 분석 실패")
+            analysis_status[pdf_id] = {"status": "error", "error": "모든 페이지 분석 실패"}
+            return {"error": "PDF 분석에 실패했습니다. API 키를 확인해주세요."}
+        
+        # 요약 생성
+        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": 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)}
+
+
+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]]:
+    try:
+        doc = fitz.open(pdf_path)
+        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} - 이미지 기반 페이지]"
+            
+            chunks.append({
+                "page": page_num + 1,
+                "text": text.strip() if text.strip() else f"[페이지 {page_num + 1}]",
+                "chunk_id": f"page_{page_num + 1}"
+            })
+        
+        doc.close()
+        return chunks
+    except Exception as e:
+        logger.error(f"PDF 텍스트 추출 오류: {e}")
+        return []
+
+
+async def query_pdf(pdf_id: str, query: str) -> Dict[str, Any]:
+    """캐시된 VLM 분석 결과를 기반으로 질의응답"""
+    try:
+        if not HAS_VALID_API_KEY:
+            return {
+                "error": "Fireworks AI API 키가 설정되지 않았습니다.",
+                "answer": "죄송합니다. 현재 AI 기능이 비활성화되어 있어 질문에 답변할 수 없습니다."
+            }
+
+        # 캐시된 분석 결과 확인
+        analysis_data = load_analysis_cache(pdf_id)
+        
+        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)
+        
+        if not analysis_text:
+            return {"error": "분석 데이터 없음", "answer": "PDF 분석 데이터를 찾을 수 없습니다."}
+
+        # 캐시된 분석 내용을 기반으로 질문에 답변
+        messages = [
+            {
+                "role": "system",
+                "content": f"""당신은 PDF 문서 분석 전문가입니다. 
+아래는 {total_pages}페이지 PDF 문서를 VLM으로 분석한 결과입니다.
+이 분석 내용을 기반으로 사용자의 질문에 정확하고 친절하게 한국어로 답변해주세요.
+답변할 때 관련 페이지 번호가 있으면 언급해주세요.
+분석 내용에 없는 정보는 "해당 정보를 찾을 수 없습니다"라고 솔직히 답해주세요.
+
+=== PDF 분석 결과 ===
+{analysis_text[:12000]}
+=================="""
+            },
+            {
+                "role": "user",
+                "content": query
+            }
+        ]
+
+        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 호출 오류: {api_error}")
+            error_message = str(api_error)
+            return {"error": f"AI 오류: {error_message}", "answer": "처리 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요."}
+            
+    except Exception as e:
+        logger.error(f"질의응답 처리 오류: {e}")
+        return {"error": str(e), "answer": "처리 중 오류가 발생했습니다."}
+
+
+async def summarize_pdf(pdf_id: str) -> Dict[str, Any]:
+    """캐시된 VLM 분석 결과에서 요약 추출"""
+    try:
+        if not HAS_VALID_API_KEY:
+            return {
+                "error": "Fireworks AI API 키가 설정되지 않았습니다.",
+                "summary": "API 키가 없어 요약을 생성할 수 없습니다."
+            }
+
+        # 캐시된 분석 결과 확인
+        analysis_data = load_analysis_cache(pdf_id)
+        
+        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가 아직 분석되지 않았습니다."}
+        
+        summary = analysis_data.get("summary", "")
+        total_pages = analysis_data.get("total_pages", 0)
+        analyzed_pages = analysis_data.get("analyzed_pages", total_pages)
+        
+        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
+            }
+        
+        return {"error": "요약 없음", "summary": "요약을 생성할 수 없습니다."}
+            
+    except Exception as e:
+        logger.error(f"PDF 요약 생성 오류: {e}")
+        return {
+            "error": str(e),
+            "summary": "PDF 요약 중 오류가 발생했습니다."
+        }
+
+
+async def cache_pdf(pdf_path: str):
+    try:
+        pdf_file = pathlib.Path(pdf_path)
+        pdf_name = pdf_file.stem
+
+        if pdf_name not in cache_locks:
+            cache_locks[pdf_name] = threading.Lock()
+
+        if pdf_name in pdf_cache and pdf_cache[pdf_name].get("status") in ["processing", "completed"]:
+            logger.info(f"PDF {pdf_name} 이미 캐싱 완료 또는 진행 중")
+            return
+
+        with cache_locks[pdf_name]:
+            if pdf_name in pdf_cache and pdf_cache[pdf_name].get("status") in ["processing", "completed"]:
+                return
+
+            pdf_cache[pdf_name] = {"status": "processing", "progress": 0, "pages": []}
+
+            cache_path = get_cache_path(pdf_name)
+            if cache_path.exists():
+                try:
+                    with open(cache_path, "r") as cache_file:
+                        cached_data = json.load(cache_file)
+                        if cached_data.get("status") == "completed" and cached_data.get("pages"):
+                            pdf_cache[pdf_name] = cached_data
+                            pdf_cache[pdf_name]["status"] = "completed"
+                            logger.info(f"캐시 파일에서 {pdf_name} 로드 완료")
+                            return
+                except Exception as e:
+                    logger.error(f"캐시 파일 로드 실패: {e}")
+
+            doc = fitz.open(pdf_path)
+            total_pages = doc.page_count
+
+            if total_pages > 0:
+                page = doc[0]
+                pix_thumb = page.get_pixmap(matrix=fitz.Matrix(0.2, 0.2))
+                thumb_data = pix_thumb.tobytes("png")
+                b64_thumb = base64.b64encode(thumb_data).decode('utf-8')
+                thumb_src = f"data:image/png;base64,{b64_thumb}"
+                pdf_cache[pdf_name]["pages"] = [{"thumb": thumb_src, "src": ""}]
+                pdf_cache[pdf_name]["progress"] = 1
+                pdf_cache[pdf_name]["total_pages"] = total_pages
+
+            scale_factor = 1.0
+            jpeg_quality = 80
+
+            def process_page(page_num):
+                try:
+                    page = doc[page_num]
+                    pix = page.get_pixmap(matrix=fitz.Matrix(scale_factor, scale_factor))
+                    img_data = pix.tobytes("jpeg", jpeg_quality)
+                    b64_img = base64.b64encode(img_data).decode('utf-8')
+                    img_src = f"data:image/jpeg;base64,{b64_img}"
+                    thumb_src = "" if page_num > 0 else pdf_cache[pdf_name]["pages"][0]["thumb"]
+                    return {
+                        "page_num": page_num,
+                        "src": img_src,
+                        "thumb": thumb_src
+                    }
+                except Exception as e:
+                    logger.error(f"페이지 {page_num} 처리 오류: {e}")
+                    return {
+                        "page_num": page_num,
+                        "src": "",
+                        "thumb": "",
+                        "error": str(e)
+                    }
+
+            pages = [None] * total_pages
+            processed_count = 0
+            batch_size = 5
+
+            for batch_start in range(0, total_pages, batch_size):
+                batch_end = min(batch_start + batch_size, total_pages)
+                current_batch = list(range(batch_start, batch_end))
+
+                with concurrent.futures.ThreadPoolExecutor(max_workers=min(5, batch_size)) as executor:
+                    batch_results = list(executor.map(process_page, current_batch))
+
+                for result in batch_results:
+                    page_num = result["page_num"]
+                    pages[page_num] = {
+                        "src": result["src"],
+                        "thumb": result["thumb"]
+                    }
+                    processed_count += 1
+                    progress = round(processed_count / total_pages * 100)
+                    pdf_cache[pdf_name]["progress"] = progress
+
+                pdf_cache[pdf_name]["pages"] = pages
+
+            pdf_cache[pdf_name] = {
+                "status": "completed",
+                "progress": 100,
+                "pages": pages,
+                "total_pages": total_pages
+            }
+
+            try:
+                with open(cache_path, "w") as cache_file:
+                    json.dump(pdf_cache[pdf_name], cache_file)
+                logger.info(f"PDF {pdf_name} 캐싱 완료, {total_pages}페이지")
+            except Exception as e:
+                logger.error(f"최종 캐시 저장 실패: {e}")
+    except Exception as e:
+        import traceback
+        logger.error(f"PDF 캐싱 오류: {str(e)}\n{traceback.format_exc()}")
+        if 'pdf_name' in locals() and pdf_name in pdf_cache:
+            pdf_cache[pdf_name]["status"] = "error"
+            pdf_cache[pdf_name]["error"] = str(e)
+
+
+@app.on_event("startup")
+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(run_initial_analysis())
+    else:
+        logger.warning(f"prompt.pdf 파일을 찾을 수 없습니다: {PROMPT_PDF_PATH}")
+
+
+@app.get("/api/pdf-info")
+async def get_pdf_info():
+    if not PROMPT_PDF_PATH.exists():
+        return {"exists": False, "error": "PDF 파일을 찾을 수 없습니다"}
+    
+    pdf_name = PROMPT_PDF_PATH.stem
+    is_cached = pdf_name in pdf_cache and pdf_cache[pdf_name].get("status") == "completed"
+    
+    # VLM 분석 캐시 확인
+    analysis_cached = load_analysis_cache(PROMPT_PDF_ID) is not None
+    
+    return {
+        "path": str(PROMPT_PDF_PATH),
+        "name": pdf_name,
+        "id": PROMPT_PDF_ID,
+        "exists": True,
+        "cached": is_cached,
+        "analysis_cached": analysis_cached
+    }
+
+
+@app.get("/api/analysis-status")
+async def get_analysis_status():
+    """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)
+        }
+    
+    # 메���리 상태 확인
+    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")
+async def reanalyze_pdf():
+    """PDF 재분석 (캐시 무시)"""
+    try:
+        if not HAS_VALID_API_KEY:
+            return JSONResponse(content={"error": "API 키가 설정되지 않았습니다."}, status_code=400)
+        
+        # 기존 캐시 삭제
+        cache_path = get_analysis_cache_path(PROMPT_PDF_ID)
+        if cache_path.exists():
+            cache_path.unlink()
+            logger.info("기존 VLM 분석 캐시 삭제")
+        
+        # 상태 초기화
+        if PROMPT_PDF_ID in analysis_status:
+            del analysis_status[PROMPT_PDF_ID]
+        
+        # 백그라운드에서 재분석 시작
+        asyncio.create_task(run_initial_analysis())
+        
+        return {"status": "started", "message": "PDF 재분석을 시작합니다."}
+    except Exception as e:
+        logger.error(f"재분석 시작 오류: {e}")
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
+
+@app.get("/api/pdf-thumbnail")
+async def get_pdf_thumbnail():
+    try:
+        if not PROMPT_PDF_PATH.exists():
+            return {"thumbnail": None, "error": "PDF 파일을 찾을 수 없습니다"}
+        
+        pdf_name = PROMPT_PDF_PATH.stem
+        if pdf_name in pdf_cache and pdf_cache[pdf_name].get("pages"):
+            if pdf_cache[pdf_name]["pages"][0].get("thumb"):
+                return {"thumbnail": pdf_cache[pdf_name]["pages"][0]["thumb"]}
+
+        doc = fitz.open(str(PROMPT_PDF_PATH))
+        if doc.page_count > 0:
+            page = doc[0]
+            pix = page.get_pixmap(matrix=fitz.Matrix(0.2, 0.2))
+            img_data = pix.tobytes("jpeg", 70)
+            b64_img = base64.b64encode(img_data).decode('utf-8')
+            asyncio.create_task(cache_pdf(str(PROMPT_PDF_PATH)))
+            return {"thumbnail": f"data:image/jpeg;base64,{b64_img}"}
+        return {"thumbnail": None}
+    except Exception as e:
+        logger.error(f"썸네일 생성 오류: {str(e)}")
+        return {"error": str(e), "thumbnail": None}
+
+
+@app.get("/api/cache-status")
+async def get_cache_status():
+    pdf_name = PROMPT_PDF_PATH.stem
+    if pdf_name in pdf_cache:
+        return pdf_cache[pdf_name]
+    return {"status": "not_cached"}
+
+
+@app.post("/api/ai/query-pdf")
+async def api_query_pdf(query: Dict[str, str]):
+    try:
+        user_query = query.get("query", "")
+        if not user_query:
+            return JSONResponse(content={"error": "질문이 제공되지 않았습니다"}, status_code=400)
+
+        if not PROMPT_PDF_PATH.exists():
+            return JSONResponse(content={"error": "PDF 파일을 찾을 수 없습니다"}, status_code=404)
+
+        result = await query_pdf(PROMPT_PDF_ID, user_query)
+        if "answer" in result:
+            return result
+        if "error" in result:
+            return JSONResponse(content=result, status_code=200)
+        return result
+    except Exception as e:
+        logger.error(f"질의응답 API 오류: {e}")
+        return JSONResponse(content={"error": str(e), "answer": "죄송합니다. 처리 중 오류가 발생했습니다."}, status_code=200)
+
+
+@app.get("/api/ai/summarize-pdf")
+async def api_summarize_pdf():
+    try:
+        if not PROMPT_PDF_PATH.exists():
+            return JSONResponse(content={"error": "PDF 파일을 찾을 수 없습니다"}, status_code=404)
+
+        result = await summarize_pdf(PROMPT_PDF_ID)
+        if "summary" in result:
+            return result
+        if "error" in result:
+            return JSONResponse(content=result, status_code=200)
+        return result
+    except Exception as e:
+        logger.error(f"PDF 요약 API 오류: {e}")
+        return JSONResponse(content={"error": str(e), "summary": "죄송합니다. 요약 생성 중 오류가 발생했습니다."}, status_code=200)
+
+
+@app.get("/api/cached-pdf")
+async def get_cached_pdf(background_tasks: BackgroundTasks):
+    try:
+        pdf_name = PROMPT_PDF_PATH.stem
+        if pdf_name in pdf_cache:
+            status = pdf_cache[pdf_name].get("status", "")
+            if status == "completed":
+                return pdf_cache[pdf_name]
+            elif status == "processing":
+                progress = pdf_cache[pdf_name].get("progress", 0)
+                pages = pdf_cache[pdf_name].get("pages", [])
+                total_pages = pdf_cache[pdf_name].get("total_pages", 0)
+                return {
+                    "status": "processing",
+                    "progress": progress,
+                    "pages": pages,
+                    "total_pages": total_pages,
+                    "available_pages": len([p for p in pages if p and p.get("src")])
+                }
+
+        background_tasks.add_task(cache_pdf, str(PROMPT_PDF_PATH))
+        return {"status": "started", "progress": 0}
+    except Exception as e:
+        logger.error(f"캐시된 PDF 제공 오류: {str(e)}")
+        return {"error": str(e), "status": "error"}
+
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    return get_html_content()
+
+
+def get_html_content():
+    return HTMLResponse(content=HTML)
+
+
+HTML = """
+<!doctype html>
+<html lang="ko">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>🎨 AI 플립북 - Comic Style</title>
+  <link rel="stylesheet" href="/static/flipbook.css">
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+  <link href="https://fonts.googleapis.com/css2?family=Bangers&family=Comic+Neue:wght@400;700&display=swap" rel="stylesheet">
+  <script src="/static/three.js"></script>
+  <script src="/static/iscroll.js"></script>
+  <script src="/static/mark.js"></script>
+  <script src="/static/mod3d.js"></script>
+  <script src="/static/pdf.js"></script>
+  <script src="/static/flipbook.js"></script>
+  <script src="/static/flipbook.book3.js"></script>
+  <script src="/static/flipbook.scroll.js"></script>
+  <script src="/static/flipbook.swipe.js"></script>
+  <script src="/static/flipbook.webgl.js"></script>
+  <style>
+  /* ============================================
+     Comic Style CSS - Z-Image Style Applied
+     ============================================ */
+  :root {
+    --primary-color: #3B82F6;
+    --secondary-color: #8B5CF6;
+    --accent-color: #FACC15;
+    --ai-color: #10B981;
+    --ai-hover: #059669;
+    --bg-yellow: #FEF9C3;
+    --text-dark: #1F2937;
+    --card-bg: #ffffff;
+    --shadow-comic: 5px 5px 0 #1F2937;
+    --shadow-lg: 8px 8px 0 #1F2937;
+    --border-comic: 3px solid #1F2937;
+    --radius-sm: 8px;
+    --radius-md: 12px;
+    --transition: all 0.2s ease;
+  }
+  
+  * {
+    box-sizing: border-box;
+  }
+  
+  body {
+    margin: 0;
+    font-family: 'Comic Neue', cursive, sans-serif;
+    color: var(--text-dark);
+    background-color: var(--bg-yellow);
+    background-image: radial-gradient(#1F2937 1px, transparent 1px);
+    background-size: 20px 20px;
+    background-attachment: fixed;
+    min-height: 100vh;
+  }
+
+  /* Header Info - Compact Comic Style */
+  .header-info {
+    position: fixed;
+    top: 10px;
+    left: 50%;
+    transform: translateX(-50%);
+    text-align: center;
+    z-index: 100;
+    background: linear-gradient(135deg, #3B82F6 0%, #8B5CF6 100%);
+    border: 3px solid #1F2937;
+    padding: 8px 25px;
+    border-radius: 10px;
+    box-shadow: 4px 4px 0 #1F2937;
+  }
+  
+  .header-info .title {
+    font-family: 'Bangers', cursive;
+    font-size: 1.3rem;
+    color: #FFF;
+    text-shadow: 2px 2px 0 #1F2937;
+    letter-spacing: 2px;
+    margin: 0;
+  }
+
+  /* Floating AI Button - Comic Style */
+  .floating-ai {
+    position: fixed;
+    top: 10px;
+    right: 20px;
+    width: 50px;
+    height: 50px;
+    border-radius: 50%;
+    background: linear-gradient(135deg, #EF4444 0%, #F97316 100%);
+    border: 3px solid #1F2937;
+    box-shadow: 4px 4px 0 #1F2937;
+    z-index: 9999;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    cursor: pointer;
+    transition: var(--transition);
+    overflow: hidden;
+  }
+  
+  .floating-ai:hover {
+    transform: translate(-2px, -2px);
+    box-shadow: 6px 6px 0 #1F2937;
+  }
+
+  .floating-ai:active {
+    transform: translate(2px, 2px);
+    box-shadow: 2px 2px 0 #1F2937;
+  }
+  
+  .floating-ai .icon {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width: 100%;
+    height: 100%;
+    font-size: 20px;
+    color: white;
+    text-shadow: 1px 1px 0 #1F2937;
+    transition: var(--transition);
+  }
+  
+  .floating-ai .ai-title {
+    position: absolute;
+    right: 58px;
+    background: #FFF;
+    padding: 8px 14px;
+    border-radius: 8px;
+    border: 2px solid #1F2937;
+    box-shadow: 3px 3px 0 #1F2937;
+    font-family: 'Bangers', cursive;
+    font-size: 0.95rem;
+    letter-spacing: 1px;
+    white-space: nowrap;
+    pointer-events: none;
+    opacity: 0;
+    transform: translateX(10px);
+    transition: all 0.3s ease;
+    color: var(--text-dark);
+  }
+  
+  .floating-ai:hover .ai-title {
+    opacity: 1;
+    transform: translateX(0);
+  }
+
+  /* Viewer Container - Comic Style */
+  #viewer {
+    width: 94%;
+    height: 90vh;
+    max-width: 94%;
+    margin: 0;
+    background: var(--card-bg);
+    border: 4px solid #1F2937;
+    border-radius: var(--radius-md);
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    z-index: 1000;
+    box-shadow: var(--shadow-lg);
+    overflow: hidden;
+  }
+
+  .flipbook-container .fb3d-menu-bar {
+    z-index: 2000 !important;
+    opacity: 1 !important;
+    bottom: 0 !important;
+    background: linear-gradient(135deg, #FACC15 0%, #F59E0B 100%) !important;
+    border-top: 3px solid #1F2937 !important;
+    border-radius: 0 0 var(--radius-md) var(--radius-md) !important;
+    padding: 12px 0 !important;
+  }
+
+  .flipbook-container .fb3d-menu-bar > ul > li > img,
+  .flipbook-container .fb3d-menu-bar > ul > li > div {
+    opacity: 1 !important;
+    transform: scale(1.2) !important;
+    filter: drop-shadow(2px 2px 0 #1F2937) !important;
+  }
+
+  .flipbook-container .fb3d-menu-bar > ul > li {
+    margin: 0 12px !important;
+  }
+
+  .flipbook-container .fb3d-menu-bar > ul > li > span {
+    background: #FFF !important;
+    color: #1F2937 !important;
+    border: 2px solid #1F2937 !important;
+    border-radius: var(--radius-sm) !important;
+    padding: 8px 12px !important;
+    font-size: 13px !important;
+    bottom: 55px !important;
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+    box-shadow: 3px 3px 0 #1F2937 !important;
+  }
+
+  @keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+  }
+
+  /* Loading Container - Comic Style */
+  .loading-container {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    text-align: center;
+    background: #FFF;
+    border: 4px solid #1F2937;
+    padding: 40px;
+    border-radius: var(--radius-md);
+    box-shadow: var(--shadow-lg);
+    z-index: 9999;
+  }
+
+  .loading-spinner {
+    border: 5px solid #FEF9C3;
+    border-top: 5px solid #3B82F6;
+    border-radius: 50%;
+    width: 55px;
+    height: 55px;
+    margin: 0 auto;
+    animation: spin 1s linear infinite;
+  }
+
+  .loading-text {
+    margin-top: 20px;
+    font-family: 'Bangers', cursive;
+    font-size: 1.3rem;
+    color: var(--text-dark);
+    letter-spacing: 1px;
+  }
+
+  .progress-bar-container {
+    width: 220px;
+    height: 20px;
+    background: #FEF9C3;
+    border: 3px solid #1F2937;
+    border-radius: 10px;
+    margin-top: 15px;
+    overflow: hidden;
+  }
+
+  .progress-bar {
+    height: 100%;
+    background: linear-gradient(to right, #3B82F6, #8B5CF6);
+    border-radius: 7px;
+    transition: width 0.3s ease;
+  }
+
+  .loading-pages {
+    position: fixed;
+    bottom: 20px;
+    left: 50%;
+    transform: translateX(-50%);
+    background: #FFF;
+    border: 3px solid #1F2937;
+    padding: 12px 25px;
+    border-radius: 25px;
+    box-shadow: 4px 4px 0 #1F2937;
+    font-family: 'Comic Neue', cursive;
+    font-size: 14px;
+    font-weight: 700;
+    color: var(--text-dark);
+    z-index: 9998;
+  }
+
+  /* AI Chat Container - Comic Style */
+  #aiChatContainer {
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: 420px;
+    height: 100%;
+    background: #FFF;
+    border-left: 4px solid #1F2937;
+    box-shadow: -8px 0 0 #1F2937;
+    z-index: 10000;
+    transform: translateX(100%);
+    transition: transform 0.3s ease;
+    display: flex;
+    flex-direction: column;
+  }
+
+  #aiChatContainer.active {
+    transform: translateX(0);
+  }
+
+  #aiChatHeader {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 20px;
+    border-bottom: 4px solid #1F2937;
+    background: linear-gradient(135deg, #EF4444 0%, #F97316 100%);
+  }
+
+  #aiChatHeader h3 {
+    margin: 0;
+    color: white;
+    font-family: 'Bangers', cursive;
+    font-size: 1.5rem;
+    letter-spacing: 2px;
+    text-shadow: 2px 2px 0 #1F2937;
+    display: flex;
+    align-items: center;
+  }
+
+  #aiChatHeader h3 i {
+    margin-right: 10px;
+  }
+
+  #aiChatClose {
+    background: #FFF;
+    border: 3px solid #1F2937;
+    cursor: pointer;
+    font-size: 18px;
+    color: #1F2937;
+    width: 40px;
+    height: 40px;
+    border-radius: 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-shadow: 3px 3px 0 #1F2937;
+    transition: var(--transition);
+  }
+
+  #aiChatClose:hover {
+    background: #FACC15;
+    transform: translate(-2px, -2px);
+    box-shadow: 5px 5px 0 #1F2937;
+  }
+
+  #aiChatMessages {
+    flex: 1;
+    overflow-y: auto;
+    padding: 20px;
+    background: #FEF9C3;
+  }
+
+  .chat-message {
+    margin-bottom: 15px;
+    display: flex;
+    align-items: flex-start;
+  }
+
+  .chat-message.user {
+    flex-direction: row-reverse;
+  }
+
+  .chat-avatar {
+    width: 40px;
+    height: 40px;
+    border-radius: 8px;
+    border: 3px solid #1F2937;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    flex-shrink: 0;
+    box-shadow: 2px 2px 0 #1F2937;
+  }
+
+  .chat-message.user .chat-avatar {
+    margin-left: 10px;
+    background: linear-gradient(135deg, #8B5CF6 0%, #A855F7 100%);
+    color: white;
+  }
+
+  .chat-message.ai .chat-avatar {
+    margin-right: 10px;
+    background: linear-gradient(135deg, #10B981 0%, #059669 100%);
+    color: white;
+  }
+
+  .chat-bubble {
+    max-width: 75%;
+  }
+
+  .chat-content {
+    padding: 14px 18px;
+    border-radius: 12px;
+    border: 3px solid #1F2937;
+    word-break: break-word;
+    font-family: 'Comic Neue', cursive;
+    font-size: 14px;
+    font-weight: 700;
+    line-height: 1.6;
+    box-shadow: 3px 3px 0 #1F2937;
+  }
+
+  .chat-message.user .chat-content {
+    background: linear-gradient(135deg, #8B5CF6 0%, #A855F7 100%);
+    color: white;
+    border-bottom-right-radius: 4px;
+  }
+
+  .chat-message.ai .chat-content {
+    background: #FFF;
+    color: #1F2937;
+    border-bottom-left-radius: 4px;
+  }
+
+  .chat-time {
+    font-size: 11px;
+    color: #6B7280;
+    margin-top: 6px;
+    text-align: right;
+    font-weight: 700;
+  }
+
+  .chat-message.ai .chat-time {
+    text-align: left;
+  }
+
+  #aiChatForm {
+    display: flex;
+    padding: 15px 20px;
+    border-top: 4px solid #1F2937;
+    background: #FFF;
+    gap: 10px;
+  }
+
+  #aiChatInput {
+    flex: 1;
+    padding: 14px 20px;
+    border: 3px solid #1F2937;
+    border-radius: 25px;
+    font-family: 'Comic Neue', cursive;
+    font-size: 14px;
+    font-weight: 700;
+    outline: none;
+    transition: var(--transition);
+    background: #FEF9C3;
+  }
+
+  #aiChatInput:focus {
+    border-color: #3B82F6;
+    box-shadow: 3px 3px 0 #3B82F6;
+  }
+
+  #aiChatSubmit {
+    background: linear-gradient(135deg, #EF4444 0%, #F97316 100%);
+    border: 3px solid #1F2937;
+    color: white;
+    width: 50px;
+    height: 50px;
+    border-radius: 50%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    cursor: pointer;
+    box-shadow: 3px 3px 0 #1F2937;
+    transition: var(--transition);
+  }
+
+  #aiChatSubmit:hover {
+    transform: translate(-2px, -2px);
+    box-shadow: 5px 5px 0 #1F2937;
+  }
+
+  #aiChatSubmit:active {
+    transform: translate(2px, 2px);
+    box-shadow: 1px 1px 0 #1F2937;
+  }
+
+  #aiChatSubmit:disabled {
+    background: #9CA3AF;
+    cursor: not-allowed;
+    transform: none;
+    box-shadow: 3px 3px 0 #1F2937;
+  }
+
+  .typing-indicator {
+    display: flex;
+    align-items: center;
+    padding: 10px;
+  }
+
+  .typing-indicator .chat-avatar {
+    margin-right: 10px;
+    background: linear-gradient(135deg, #10B981 0%, #059669 100%);
+    color: white;
+  }
+
+  .typing-indicator span {
+    height: 10px;
+    width: 10px;
+    background: #10B981;
+    border-radius: 50%;
+    display: inline-block;
+    margin-right: 5px;
+    border: 2px solid #1F2937;
+    animation: typing 1s infinite;
+  }
+
+  .typing-indicator span:nth-child(2) { animation-delay: 0.2s; }
+  .typing-indicator span:nth-child(3) { animation-delay: 0.4s; }
+
+  @keyframes typing {
+    0%, 100% { transform: translateY(0); }
+    50% { transform: translateY(-8px); }
+  }
+
+  .error-container {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    text-align: center;
+    background: #FFF;
+    border: 4px solid #1F2937;
+    padding: 40px;
+    border-radius: var(--radius-md);
+    box-shadow: var(--shadow-lg);
+    z-index: 9999;
+  }
+
+  .error-container i {
+    font-size: 50px;
+    color: #EF4444;
+    margin-bottom: 20px;
+    text-shadow: 3px 3px 0 #1F2937;
+  }
+
+  .error-container p {
+    font-family: 'Comic Neue', cursive;
+    font-size: 16px;
+    font-weight: 700;
+    color: var(--text-dark);
+    margin-bottom: 20px;
+  }
+
+  .error-container button {
+    padding: 12px 30px;
+    background: linear-gradient(135deg, #3B82F6 0%, #8B5CF6 100%);
+    color: white;
+    border: 3px solid #1F2937;
+    border-radius: 8px;
+    cursor: pointer;
+    font-family: 'Bangers', cursive;
+    font-size: 1.2rem;
+    letter-spacing: 1px;
+    box-shadow: 4px 4px 0 #1F2937;
+    transition: var(--transition);
+  }
+
+  .error-container button:hover {
+    transform: translate(-2px, -2px);
+    box-shadow: 6px 6px 0 #1F2937;
+  }
+
+  /* Footer - Comic Style */
+  .footer-comic {
+    position: fixed;
+    bottom: 10px;
+    right: 10px;
+    text-align: center;
+    padding: 10px 20px;
+    background: linear-gradient(135deg, #3B82F6 0%, #8B5CF6 100%);
+    border: 3px solid #1F2937;
+    border-radius: 10px;
+    box-shadow: 4px 4px 0 #1F2937;
+    z-index: 100;
+  }
+
+  .footer-comic p {
+    font-family: 'Comic Neue', cursive;
+    color: #FFF;
+    margin: 3px 0;
+    font-weight: 700;
+    font-size: 0.85rem;
+  }
+
+  .footer-comic a {
+    color: #FACC15;
+    text-decoration: none;
+    font-weight: 700;
+  }
+
+  .footer-comic a:hover {
+    text-decoration: underline;
+  }
+
+  /* Scrollbar - Comic Style */
+  ::-webkit-scrollbar {
+    width: 14px;
+    height: 14px;
+  }
+
+  ::-webkit-scrollbar-track {
+    background: #FEF9C3;
+    border: 2px solid #1F2937;
+  }
+
+  ::-webkit-scrollbar-thumb {
+    background: linear-gradient(135deg, #3B82F6, #8B5CF6);
+    border: 2px solid #1F2937;
+    border-radius: 7px;
+  }
+
+  ::-webkit-scrollbar-thumb:hover {
+    background: linear-gradient(135deg, #EF4444, #F97316);
+  }
+
+  ::selection {
+    background: #FACC15;
+    color: #1F2937;
+  }
+
+  @media (max-width: 768px) {
+    .header-info {
+      top: 8px;
+      padding: 6px 15px;
+      max-width: 70%;
+    }
+    
+    .header-info .title {
+      font-size: 1.1rem;
+    }
+    
+    .floating-ai {
+      width: 45px;
+      height: 45px;
+      top: 8px;
+      right: 10px;
+    }
+    
+    .floating-ai .icon {
+      font-size: 18px;
+    }
+    
+    #aiChatContainer {
+      width: 100%;
+    }
+    
+    #viewer {
+      width: 98%;
+      height: 92vh;
+      top: 50%;
+    }
+
+    .footer-comic {
+      display: none;
+    }
+  }
+  </style>
+</head>
+<body>
+  <!-- Header Info - Compact Comic Style -->
+  <div class="header-info">
+    <div class="title">📚 AI 플립북</div>
+  </div>
+
+  <!-- Floating AI Button - Comic Style -->
+  <div id="aiButton" class="floating-ai">
+    <div class="icon"><i class="fas fa-robot"></i></div>
+    <div class="ai-title">🤖 AI 어시스턴트</div>
+  </div>
+
+  <!-- AI Chat Container -->
+  <div id="aiChatContainer">
+    <div id="aiChatHeader">
+      <h3><i class="fas fa-robot"></i> AI 어시스턴트</h3>
+      <button id="aiChatClose"><i class="fas fa-times"></i></button>
+    </div>
+    <div id="aiChatMessages"></div>
+    <form id="aiChatForm">
+      <input type="text" id="aiChatInput" placeholder="PDF에 대해 질문하세요..." autocomplete="off">
+      <button type="submit" id="aiChatSubmit"><i class="fas fa-paper-plane"></i></button>
+    </form>
+  </div>
+
+  <!-- PDF Viewer -->
+  <div id="viewer"></div>
+  <div id="loadingPages" class="loading-pages" style="display:none;">페이지 로딩 중... <span id="loadingPagesCount">0%</span></div>
+
+  <!-- Footer - Comic Style -->
+  <div class="footer-comic">
+    <p style="font-family:'Bangers',cursive;font-size:1.1rem;letter-spacing:1px">📚 AI FLIPBOOK 📚</p>
+    <p>Powered by VLM + 3D FlipBook</p>
+    <p><a href="https://ginigen.ai" target="_blank">🏠 ginigen.ai</a></p>
+  </div>
+
+<script>
+    let fb = null;
+    const viewer = document.getElementById('viewer');
+    pdfjsLib.GlobalWorkerOptions.workerSrc = '/static/pdf.worker.js';
+    
+    let pageLoadingInterval = null;
+    let audioInitialized = false;
+    let isAiChatActive = false;
+    let isAiProcessing = false;
+    let hasLoadedSummary = false;
+    let analysisCheckInterval = null;
+
+    function $id(id) { return document.getElementById(id); }
+
+    function formatTime() {
+      const now = new Date();
+      return now.toLocaleTimeString('ko-KR', { hour: '2-digit', minute: '2-digit' });
+    }
+
+    function initializeAudio() {
+      if (audioInitialized) return Promise.resolve();
+      return new Promise((resolve) => {
+        const audio = new Audio('/static/turnPage2.mp3');
+        audio.volume = 0.01;
+        audio.play().then(() => {
+          audio.pause();
+          audioInitialized = true;
+          resolve();
+        }).catch(() => {
+          const initOnClick = () => {
+            const tempAudio = new Audio('/static/turnPage2.mp3');
+            tempAudio.volume = 0.01;
+            tempAudio.play().then(() => {
+              tempAudio.pause();
+              audioInitialized = true;
+              document.removeEventListener('click', initOnClick);
+              resolve();
+            }).catch(() => {});
+          };
+          document.addEventListener('click', initOnClick, { once: true });
+          resolve();
+        });
+      });
+    }
+
+    function addChatMessage(content, isUser = false) {
+      const messagesContainer = $id('aiChatMessages');
+      const messageElement = document.createElement('div');
+      messageElement.className = `chat-message ${isUser ? 'user' : 'ai'}`;
+      messageElement.innerHTML = `
+        <div class="chat-avatar">
+          <i class="fas ${isUser ? 'fa-user' : 'fa-robot'}"></i>
+        </div>
+        <div class="chat-bubble">
+          <div class="chat-content">${content}</div>
+          <div class="chat-time">${formatTime()}</div>
+        </div>
+      `;
+      messagesContainer.appendChild(messageElement);
+      messagesContainer.scrollTop = messagesContainer.scrollHeight;
+      return messageElement;
+    }
+
+    function addTypingIndicator() {
+      const messagesContainer = $id('aiChatMessages');
+      const indicator = document.createElement('div');
+      indicator.className = 'typing-indicator';
+      indicator.id = 'typingIndicator';
+      indicator.innerHTML = `
+        <div class="chat-avatar"><i class="fas fa-robot"></i></div>
+        <div><span></span><span></span><span></span></div>
+      `;
+      messagesContainer.appendChild(indicator);
+      messagesContainer.scrollTop = messagesContainer.scrollHeight;
+      return indicator;
+    }
+
+    function removeTypingIndicator() {
+      const indicator = $id('typingIndicator');
+      if (indicator) indicator.remove();
+    }
+
+    function toggleAiChat(show = true) {
+      const container = $id('aiChatContainer');
+      if (show) {
+        container.classList.add('active');
+        isAiChatActive = true;
+        if (!hasLoadedSummary) {
+          loadPdfSummary();
+        }
+        $id('aiChatInput').focus();
+      } else {
+        container.classList.remove('active');
+        isAiChatActive = false;
+      }
+    }
+
+    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;
+      
+      try {
+        isAiProcessing = true;
+        addTypingIndicator();
+        
+        // 분석 상태 확인
+        const statusData = await checkAnalysisStatus();
+        
+        if (statusData.status === 'analyzing') {
+          removeTypingIndicator();
+          const progress = statusData.progress || 0;
+          addChatMessage(`안녕하세요! 💥 현재 PDF를 AI가 분석하고 있습니다. 📊<br><br>진행률: <strong>${progress}%</strong><br><small style="color:#6B7280;">분석이 완료되면 자동으로 알려드리겠습니다.</small>`);
+          hasLoadedSummary = true;
+          isAiProcessing = false;
+          
+          // 분석 완료 폴링
+          startAnalysisPolling();
+          return;
+        }
+        
+        if (statusData.status === 'error') {
+          removeTypingIndicator();
+          addChatMessage(`안녕하세요! 💥 PDF 분석 중 오류가 발생했습니다. ⚠️<br><br><small style="color:#EF4444;">${statusData.error || '알 수 없는 오류'}</small><br><br>페이지를 새로고침하거나 잠시 후 다시 시도해주세요.`);
+          hasLoadedSummary = true;
+          isAiProcessing = false;
+          return;
+        }
+        
+        if (statusData.status === 'not_started') {
+          removeTypingIndicator();
+          addChatMessage(`안녕하세요! 💥 PDF 분석이 아직 시작되지 않았습니다. 🔄<br><br><small style="color:#6B7280;">잠시만 기다려주세요...</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.analyzed_pages ? ` (${data.analyzed_pages}/${data.total_pages}페이지 분석완료)` : '';
+          addChatMessage(`안녕하세요! 💥 이 PDF에 대해 무엇이든 질문해주세요.${pageInfo}<br><br><strong>📄 PDF 요약:</strong><br>${data.summary}`);
+        } else {
+          addChatMessage("안녕하세요! 💥 PDF에 대해 질문해주세요. 최선을 다해 답변하겠습니다.");
+        }
+        hasLoadedSummary = true;
+        
+      } catch (error) {
+        console.error("PDF 요약 로드 오류:", error);
+        removeTypingIndicator();
+        addChatMessage("안녕하세요! 💥 PDF에 대해 질문해주세요.");
+        hasLoadedSummary = true;
+      } finally {
+        isAiProcessing = false;
+      }
+    }
+    
+    function startAnalysisPolling() {
+      if (analysisCheckInterval) return;
+      
+      analysisCheckInterval = setInterval(async () => {
+        try {
+          const data = await checkAnalysisStatus();
+          
+          if (data.status === 'completed') {
+            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);
+        }
+      }, 5000);  // 5초마다 확인
+      
+      // 5분 후 자동 중지
+      setTimeout(() => {
+        if (analysisCheckInterval) {
+          clearInterval(analysisCheckInterval);
+          analysisCheckInterval = null;
+        }
+      }, 300000);
+    }
+
+    async function submitQuestion(question) {
+      if (isAiProcessing || !question.trim()) return;
+      
+      try {
+        isAiProcessing = true;
+        $id('aiChatSubmit').disabled = true;
+        
+        addChatMessage(question, true);
+        
+        // 분석 상태 확인
+        const statusData = await checkAnalysisStatus();
+        
+        if (statusData.status !== 'completed') {
+          if (statusData.status === 'analyzing') {
+            addChatMessage(`PDF 분석이 진행 중입니다 (${statusData.progress || 0}%). 완료 후 질문해주세요. ⏳`);
+          } else {
+            addChatMessage("PDF 분석이 아직 완료되지 않았습니다. 잠시만 기다려주세요.");
+          }
+          isAiProcessing = false;
+          $id('aiChatSubmit').disabled = false;
+          $id('aiChatInput').value = question;
+          return;
+        }
+        
+        addTypingIndicator();
+        
+        const response = await fetch('/api/ai/query-pdf', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ query: question }),
+          signal: AbortSignal.timeout(120000)
+        });
+        
+        const data = await response.json();
+        removeTypingIndicator();
+        
+        if (data.answer) {
+          addChatMessage(data.answer);
+        } else if (data.error) {
+          addChatMessage(`죄송합니다. ${data.error}`);
+        } else {
+          addChatMessage("죄송합니다. 답변을 생성하지 못했습니다.");
+        }
+      } catch (error) {
+        console.error("질문 제출 오류:", error);
+        removeTypingIndicator();
+        if (error.name === 'AbortError') {
+          addChatMessage("응답 시간이 초과되었습니다. 잠시 후 다시 시도해주세요.");
+        } else {
+          addChatMessage("서버와 통신 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요.");
+        }
+      } finally {
+        isAiProcessing = false;
+        $id('aiChatSubmit').disabled = false;
+        $id('aiChatInput').value = '';
+        $id('aiChatInput').focus();
+      }
+    }
+
+    function showLoading(message) {
+      hideLoading();
+      const container = document.createElement('div');
+      container.className = 'loading-container';
+      container.id = 'loadingContainer';
+      container.innerHTML = `
+        <div class="loading-spinner"></div>
+        <p class="loading-text">${message || '로딩 중...'}</p>
+        <div class="progress-bar-container">
+          <div id="progressBar" class="progress-bar" style="width: 0%;"></div>
+        </div>
+      `;
+      document.body.appendChild(container);
+    }
+
+    function updateLoading(message, progress) {
+      const text = document.querySelector('.loading-text');
+      if (text) text.textContent = message;
+      const bar = $id('progressBar');
+      if (bar && progress !== undefined) bar.style.width = `${progress}%`;
+    }
+
+    function hideLoading() {
+      const container = $id('loadingContainer');
+      if (container) container.remove();
+    }
+
+    function showError(message) {
+      hideLoading();
+      const container = document.createElement('div');
+      container.className = 'error-container';
+      container.id = 'errorContainer';
+      container.innerHTML = `
+        <i class="fas fa-exclamation-circle"></i>
+        <p>${message}</p>
+        <button onclick="location.reload()">다시 시도</button>
+      `;
+      document.body.appendChild(container);
+    }
+
+    function createFlipBook(pages) {
+      try {
+        const windowWidth = window.innerWidth;
+        const windowHeight = window.innerHeight;
+        const aspectRatio = windowWidth / windowHeight;
+        
+        let width, height;
+        if (aspectRatio > 1) {
+          // 가로 모드: 높이 기준으로 90% 사용
+          height = Math.min(windowHeight * 0.88, windowHeight - 60);
+          width = height * aspectRatio * 0.75;
+          if (width > windowWidth * 0.94) {
+            width = windowWidth * 0.94;
+            height = width / (aspectRatio * 0.75);
+          }
+        } else {
+          // 세로 모드: 너비 기준으로 98% 사용
+          width = Math.min(windowWidth * 0.98, windowWidth - 10);
+          height = width / aspectRatio * 0.9;
+          if (height > windowHeight * 0.9) {
+            height = windowHeight * 0.9;
+            width = height * aspectRatio * 0.9;
+          }
+        }
+
+        viewer.style.width = Math.round(width) + 'px';
+        viewer.style.height = Math.round(height) + 'px';
+
+        const validPages = pages.map(page => {
+          if (!page || !page.src) {
+            return {
+              src: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAwIiBoZWlnaHQ9IjEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cmVjdCB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBmaWxsPSIjZjVmNWY1Ii8+PC9zdmc+',
+              thumb: ''
+            };
+          }
+          return page;
+        });
+
+        fb = new FlipBook(viewer, {
+          pages: validPages,
+          viewMode: 'webgl',
+          autoSize: true,
+          flipDuration: 800,
+          backgroundColor: '#fff',
+          sound: true,
+          assets: { flipMp3: '/static/turnPage2.mp3', hardFlipMp3: '/static/turnPage2.mp3' },
+          controlsProps: {
+            enableFullscreen: true,
+            enableToc: true,
+            enableDownload: false,
+            enablePrint: false,
+            enableZoom: true,
+            enableShare: false,
+            enableSearch: true,
+            enableAutoPlay: true,
+            enableSound: true,
+            layout: 10,
+            skin: 'light',
+            autoNavigationTime: 3600,
+            hideControls: false,
+            paddingTop: 10,
+            paddingLeft: 10,
+            paddingRight: 10,
+            paddingBottom: 10,
+            pageTextureSize: 1024,
+            thumbnails: true,
+            autoHideControls: false,
+            controlsTimeout: 8000
+          }
+        });
+
+        window.addEventListener('resize', () => {
+          if (fb) fb.resize();
+        });
+
+        console.log('FlipBook 생성 완료');
+      } catch (error) {
+        console.error('FlipBook 생성 오류:', error);
+        showError("플립북을 생성하는 중 오류가 발생했습니다.");
+      }
+    }
+
+    async function loadPDF() {
+      try {
+        showLoading("PDF 정보 확인 중...");
+        
+        const infoResponse = await fetch('/api/pdf-info');
+        const pdfInfo = await infoResponse.json();
+        
+        if (!pdfInfo.exists) {
+          hideLoading();
+          showError("PDF 파일을 찾을 수 없습니다. prompt.pdf 파일을 확인해주세요.");
+          return;
+        }
+
+        updateLoading("PDF 로딩 중...", 10);
+
+        if (pdfInfo.cached) {
+          const cacheResponse = await fetch('/api/cached-pdf');
+          const cachedData = await cacheResponse.json();
+          
+          if (cachedData.status === "completed" && cachedData.pages) {
+            hideLoading();
+            createFlipBook(cachedData.pages);
+            return;
+          }
+        }
+
+        const cacheResponse = await fetch('/api/cached-pdf');
+        let cachedData = await cacheResponse.json();
+
+        if (cachedData.status === "completed" && cachedData.pages) {
+          hideLoading();
+          createFlipBook(cachedData.pages);
+          return;
+        }
+
+        while (cachedData.status === "processing" || cachedData.status === "started") {
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          
+          const statusResponse = await fetch('/api/cache-status');
+          cachedData = await statusResponse.json();
+          
+          if (cachedData.progress) {
+            updateLoading(`PDF 처리 중... ${cachedData.progress}%`, cachedData.progress);
+          }
+          
+          if (cachedData.status === "completed") {
+            const finalResponse = await fetch('/api/cached-pdf');
+            cachedData = await finalResponse.json();
+            break;
+          }
+        }
+
+        hideLoading();
+        
+        if (cachedData.pages && cachedData.pages.length > 0) {
+          createFlipBook(cachedData.pages);
+        } else {
+          showError("PDF를 처리할 수 없습니다.");
+        }
+
+      } catch (error) {
+        console.error("PDF 로드 오류:", error);
+        hideLoading();
+        showError("PDF를 로드하는 중 오류가 발생했습니다.");
+      }
+    }
+
+    document.addEventListener('DOMContentLoaded', function() {
+      initializeAudio();
+
+      $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();
+        if (question && !isAiProcessing) {
+          submitQuestion(question);
+        }
+      });
+
+      loadPDF();
+    });
+</script>
+</body>
+</html>
+"""
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", 7860)))