Update app.py

app.py

@@ -7,6 +7,8 @@ import asyncio
 import logging
 import threading
 import concurrent.futures
+from openai import OpenAI
+import fitz  # PyMuPDF
 
 # 로깅 설정
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -37,15 +39,38 @@ if not METADATA_DIR.exists():
     METADATA_DIR.mkdir(parents=True)
 PDF_METADATA_FILE = METADATA_DIR / "pdf_metadata.json"
 
+# 임베딩 캐시 디렉토리 설정
+EMBEDDING_DIR = pathlib.Path("/data/embeddings") if os.path.exists("/data") else BASE / "embeddings"
+if not EMBEDDING_DIR.exists():
+    EMBEDDING_DIR.mkdir(parents=True)
+
 # 관리자 비밀번호
 ADMIN_PASSWORD = os.getenv("PASSWORD", "admin")  # 환경 변수에서 가져오기, 기본값은 테스트용
 
+# OpenAI API 키 설정
+OPENAI_API_KEY = os.getenv("LLM_API", "")
+# API 키가 없거나 비어있을 때 플래그 설정
+HAS_VALID_API_KEY = bool(OPENAI_API_KEY and OPENAI_API_KEY.strip())
+
+if HAS_VALID_API_KEY:
+    try:
+        openai_client = OpenAI(api_key=OPENAI_API_KEY, timeout=30.0)
+        logger.info("OpenAI 클라이언트 초기화 성공")
+    except Exception as e:
+        logger.error(f"OpenAI 클라이언트 초기화 실패: {e}")
+        HAS_VALID_API_KEY = False
+else:
+    logger.warning("유효한 OpenAI API 키가 없습니다. AI 기능이 제한됩니다.")
+    openai_client = None
+
 # 전역 캐시 객체
 pdf_cache: Dict[str, Dict[str, Any]] = {}
 # 캐싱 락
 cache_locks = {}
 # PDF 메타데이터 (ID to 경로 매핑)
 pdf_metadata: Dict[str, str] = {}
+# PDF 임베딩 캐시
+pdf_embeddings: Dict[str, Dict[str, Any]] = {}
 
 # PDF 메타데이터 로드
 def load_pdf_metadata():
@@ -69,7 +94,6 @@ def save_pdf_metadata():
     except Exception as e:
         logger.error(f"메타데이터 저장 오류: {e}")
 
-# PDF ID 생성 (파일명 + 타임스탬프 기반)
 # PDF ID 생성 (파일명 + 타임스탬프 기반) - 더 단순하고 안전한 방식으로 변경
 def generate_pdf_id(filename: str) -> str:
     # 파일명에서 확장자 제거
@@ -83,8 +107,6 @@ def generate_pdf_id(filename: str) -> str:
     random_suffix = uuid.uuid4().hex[:6]
     return f"{safe_name}_{timestamp}_{random_suffix}"
 
-
-
 # PDF 파일 목록 가져오기 (메인 디렉토리용)
 def get_pdf_files():
     pdf_files = []
@@ -146,6 +168,225 @@ def generate_pdf_projects():
 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"
+
+# PDF 텍스트 추출 함수
+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()
+            
+            # 페이지 텍스트가 있는 경우만 추가
+            if text.strip():
+                chunks.append({
+                    "page": page_num + 1,
+                    "text": text,
+                    "chunk_id": f"page_{page_num + 1}"
+                })
+        
+        return chunks
+    except Exception as e:
+        logger.error(f"PDF 텍스트 추출 오류: {e}")
+        return []
+
+# PDF ID로 임베딩 생성 또는 가져오기
+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 경로 찾기
+        pdf_path = get_pdf_path_by_id(pdf_id)
+        if not pdf_path:
+            raise ValueError(f"PDF ID {pdf_id}에 해당하는 파일을 찾을 수 없습니다")
+        
+        # 텍스트 추출
+        chunks = extract_pdf_text(pdf_path)
+        if not chunks:
+            raise ValueError(f"PDF에서 텍스트를 추출할 수 없습니다: {pdf_path}")
+        
+        # 임베딩 저장 및 반환
+        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}
+
+# PDF 내용 기반 질의응답
+# PDF 내용 기반 질의응답 함수 개선
+async def query_pdf(pdf_id: str, query: str) -> Dict[str, Any]:
+    try:
+        # API 키가 없거나 유효하지 않은 경우
+        if not HAS_VALID_API_KEY or not openai_client:
+            return {
+                "error": "OpenAI API 키가 설정되지 않았습니다.",
+                "answer": "죄송합니다. 현재 AI 기능이 비활성화되어 있어 질문에 답변할 수 없습니다. 시스템 관리자에게 문의하세요."
+            }
+        
+        # 임베딩 데이터 가져오기
+        embedding_data = await get_pdf_embedding(pdf_id)
+        if "error" in embedding_data:
+            return {"error": embedding_data["error"]}
+        
+        # 청크 텍스트 모으기 (임시로 간단하게 전체 텍스트 사용)
+        all_text = "\n\n".join([f"Page {chunk['page']}: {chunk['text']}" for chunk in embedding_data["chunks"]])
+        
+        # 컨텍스트 크기를 고려하여 텍스트가 너무 길면 앞부분만 사용
+        max_context_length = 60000  # 토큰 수가 아닌 문자 수 기준 (대략적인 제한)
+        if len(all_text) > max_context_length:
+            all_text = all_text[:max_context_length] + "...(이하 생략)"
+        
+        # 시스템 프롬프트 준비
+        system_prompt = """
+        당신은 PDF 내용을 기반으로 질문에 답변하는 도우미입니다. 제공된 PDF 컨텍스트 정보만을 사용하여 답변하세요.
+        컨텍스트에 관련 정보가 없는 경우, '제공된 PDF에서 해당 정보를 찾을 수 없습니다'라고 솔직히 답하세요.
+        답변은 명확하고 간결하게 작성하고, 관련 페이지 번호를 인용하세요.
+        """
+        
+        # gpt-4.1-mini 모델 사용
+        try:
+            # 타임아웃 및 재시도 설정 개선
+            for attempt in range(3):  # 최대 3번 재시도
+                try:
+                    response = openai_client.chat.completions.create(
+                        model="gpt-4.1-mini",
+                        messages=[
+                            {"role": "system", "content": system_prompt},
+                            {"role": "user", "content": f"다음 PDF 내용을 참고하여 질문에 답변해주세요.\n\nPDF 내용:\n{all_text}\n\n질문: {query}"}
+                        ],
+                        temperature=0.7,
+                        max_tokens=2048,
+                        timeout=30.0  # 30초 타임아웃
+                    )
+                    
+                    answer = response.choices[0].message.content
+                    return {
+                        "answer": answer,
+                        "pdf_id": pdf_id,
+                        "query": query
+                    }
+                except Exception as api_error:
+                    logger.error(f"OpenAI API 호출 오류 (시도 {attempt+1}/3): {api_error}")
+                    if attempt == 2:  # 마지막 시도에서도 실패
+                        raise api_error
+                    await asyncio.sleep(1 * (attempt + 1))  # 재시도 간 지연 시간 증가
+            
+            # 여기까지 도달하지 않아야 함
+            raise Exception("API 호출 재시도 모두 실패")
+        except Exception as api_error:
+            logger.error(f"OpenAI API 호출 최종 오류: {api_error}")
+            # 오류 유형에 따른 더 명확한 메시지 제공
+            error_message = str(api_error)
+            if "Connection" in error_message:
+                return {"error": "OpenAI 서버와 연결할 수 없습니다. 인터넷 연결을 확인하세요."}
+            elif "Unauthorized" in error_message or "Authentication" in error_message:
+                return {"error": "API 키가 유효하지 않습니다."}
+            elif "Rate limit" in error_message:
+                return {"error": "API 호출 한도를 초과했습니다. 잠시 후 다시 시도하세요."}
+            else:
+                return {"error": f"AI 응답 생성 중 오류가 발생했습니다: {error_message}"}
+        
+    except Exception as e:
+        logger.error(f"질의응답 처리 오류: {e}")
+        return {"error": str(e)}
+
+# PDF 요약 생성
+# PDF 요약 생성 함수 개선
+async def summarize_pdf(pdf_id: str) -> Dict[str, Any]:
+    try:
+        # API 키가 없거나 유효하지 않은 경우
+        if not HAS_VALID_API_KEY or not openai_client:
+            return {
+                "error": "OpenAI API 키가 설정되지 않았습니다. 'LLM_API' 환경 변수를 확인하세요.",
+                "summary": "API 키가 없어 요약을 생성할 수 없습니다. 시스템 관리자에게 문의하세요."
+            }
+        
+        # 임베딩 데이터 가져오기
+        embedding_data = await get_pdf_embedding(pdf_id)
+        if "error" in embedding_data:
+            return {"error": embedding_data["error"], "summary": "PDF에서 텍스트를 추출할 수 없습니다."}
+        
+        # 청크 텍스트 모으기 (제한된 길이)
+        all_text = "\n\n".join([f"Page {chunk['page']}: {chunk['text']}" for chunk in embedding_data["chunks"]])
+        
+        # 컨텍스트 크기를 고려하여 텍스트가 너무 길면 앞부분만 사���
+        max_context_length = 60000  # 토큰 수가 아닌 문자 수 기준 (대략적인 제한)
+        if len(all_text) > max_context_length:
+            all_text = all_text[:max_context_length] + "...(이하 생략)"
+        
+        # OpenAI API 호출
+        try:
+            # 타임아웃 및 재시도 설정 개선
+            for attempt in range(3):  # 최대 3번 재시도
+                try:
+                    response = openai_client.chat.completions.create(
+                        model="gpt-4.1-mini",
+                        messages=[
+                            {"role": "system", "content": "다음 PDF 내용을 간결하게 요약해주세요. 핵심 주제와 주요 포인트를 포함한 요약을 500자 이내로 작성해주세요."},
+                            {"role": "user", "content": f"PDF 내용:\n{all_text}"}
+                        ],
+                        temperature=0.7,
+                        max_tokens=1024,
+                        timeout=30.0  # 30초 타임아웃
+                    )
+                    
+                    summary = response.choices[0].message.content
+                    return {
+                        "summary": summary,
+                        "pdf_id": pdf_id
+                    }
+                except Exception as api_error:
+                    logger.error(f"OpenAI API 호출 오류 (시도 {attempt+1}/3): {api_error}")
+                    if attempt == 2:  # 마지막 시도에서도 실패
+                        raise api_error
+                    await asyncio.sleep(1 * (attempt + 1))  # 재시도 간 지연 시간 증가
+            
+            # 여기까지 도달하지 않아야 함
+            raise Exception("API 호출 재시도 모두 실패")
+        except Exception as api_error:
+            logger.error(f"OpenAI API 호출 최종 오류: {api_error}")
+            # 오류 유형에 따른 더 명확한 메시지 제공
+            error_message = str(api_error)
+            if "Connection" in error_message:
+                return {"error": "OpenAI 서버와 연결할 수 없습니다. 인터넷 연결을 확인하세요.", "pdf_id": pdf_id}
+            elif "Unauthorized" in error_message or "Authentication" in error_message:
+                return {"error": "API 키가 유효하지 않습니다.", "pdf_id": pdf_id}
+            elif "Rate limit" in error_message:
+                return {"error": "API 호출 한도를 초과했습니다. 잠시 후 다시 시도하세요.", "pdf_id": pdf_id}
+            else:
+                return {"error": f"AI 요약 생성 중 오류가 발생했습니다: {error_message}", "pdf_id": pdf_id}
+    
+    except Exception as e:
+        logger.error(f"PDF 요약 생성 오류: {e}")
+        return {
+            "error": str(e),
+            "summary": "PDF 요약 중 오류가 발생했습니다. PDF 페이지 수가 너무 많거나 형식이 지원되지 않을 수 있습니다."
+        }
+
+        
 # 최적화된 PDF 페이지 캐싱 함수
 async def cache_pdf(pdf_path: str):
     try:
@@ -300,7 +541,6 @@ async def cache_pdf(pdf_path: str):
             pdf_cache[pdf_name]["status"] = "error"
             pdf_cache[pdf_name]["error"] = str(e)
 
-# PDF ID로 PDF 경로 찾기
 # PDF ID로 PDF 경로 찾기 (개선된 검색 로직)
 def get_pdf_path_by_id(pdf_id: str) -> str:
     logger.info(f"PDF ID로 파일 조회: {pdf_id}")
@@ -534,6 +774,50 @@ async def get_cache_status(path: str = None):
         return {name: {"status": info["status"], "progress": info.get("progress", 0)} 
                 for name, info in pdf_cache.items()}
 
+# API 엔드포인트: PDF에 대한 질의응답
+@app.post("/api/ai/query-pdf/{pdf_id}")
+async def api_query_pdf(pdf_id: str, query: Dict[str, str]):
+    try:
+        user_query = query.get("query", "")
+        if not user_query:
+            return JSONResponse(content={"error": "질문이 제공되지 않았습니다"}, status_code=400)
+        
+        # PDF 경로 확인
+        pdf_path = get_pdf_path_by_id(pdf_id)
+        if not pdf_path:
+            return JSONResponse(content={"error": f"PDF ID {pdf_id}에 해당하는 파일을 찾을 수 없습니다"}, status_code=404)
+        
+        # 질의응답 처리
+        result = await query_pdf(pdf_id, user_query)
+        
+        if "error" in result:
+            return JSONResponse(content={"error": result["error"]}, status_code=500)
+        
+        return result
+    except Exception as e:
+        logger.error(f"질의응답 API 오류: {e}")
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
+# API 엔드포인트: PDF 요약
+@app.get("/api/ai/summarize-pdf/{pdf_id}")
+async def api_summarize_pdf(pdf_id: str):
+    try:
+        # PDF 경로 확인
+        pdf_path = get_pdf_path_by_id(pdf_id)
+        if not pdf_path:
+            return JSONResponse(content={"error": f"PDF ID {pdf_id}에 해당하는 파일을 찾을 수 없습니다"}, status_code=404)
+        
+        # 요약 처리
+        result = await summarize_pdf(pdf_id)
+        
+        if "error" in result:
+            return JSONResponse(content={"error": result["error"]}, status_code=500)
+        
+        return result
+    except Exception as e:
+        logger.error(f"PDF 요약 API 오류: {e}")
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
 # API 엔드포인트: 캐시된 PDF 콘텐츠 제공 (점진적 로딩 지원)
 @app.get("/api/cached-pdf")
 async def get_cached_pdf(path: str, background_tasks: BackgroundTasks):
@@ -818,7 +1102,7 @@ async def root(request: Request, pdf_id: Optional[str] = Query(None)):
         return RedirectResponse(url=f"/view/{pdf_id}")
     return get_html_content()
 
-# HTML 문자열 (UI 수정 버전)
+# HTML 문자열 (AI 버튼 및 챗봇 UI 추가)
 HTML = """
 <!doctype html>
 <html lang="ko">
@@ -844,6 +1128,8 @@ HTML = """
     --secondary-color: #ffd6e0; /* 파스텔 핑크 */
     --tertiary-color: #c3fae8; /* 파스텔 민트 */
     --accent-color: #d0bfff; /* 파스텔 퍼플 */
+    --ai-color: #86e8ab; /* AI 버튼 색상 */
+    --ai-hover: #65d68a; /* AI 호버 색상 */
     --bg-color: #f8f9fa; /* 밝은 배경 */
     --text-color: #495057; /* 부드러운 어두운 색 */
     --card-bg: #ffffff; /* 카드 배경색 */
@@ -873,7 +1159,7 @@ HTML = """
     }
 
   /* 헤더 제목 제거 및 Home 버튼 레이어 처리 */
-  .floating-home {
+  .floating-home, .floating-ai {
     position: fixed;
     top: 20px;
     left: 20px;
@@ -892,12 +1178,17 @@ HTML = """
     overflow: hidden;
   }
   
-  .floating-home:hover {
+  .floating-ai {
+    top: 90px; /* Home 버튼 아래에 위치 */
+    background: rgba(134, 232, 171, 0.9); /* AI 버튼 색상 */
+  }
+  
+  .floating-home:hover, .floating-ai:hover {
     transform: scale(1.05);
     box-shadow: var(--shadow-lg);
   }
   
-  .floating-home .icon {
+  .floating-home .icon, .floating-ai .icon {
     display: flex;
     justify-content: center;
     align-items: center;
@@ -908,11 +1199,19 @@ HTML = """
     transition: var(--transition);
   }
   
+  .floating-ai .icon {
+    color: white;
+  }
+  
   .floating-home:hover .icon {
     color: #8bc5f8;
   }
   
-  .floating-home .title {
+  .floating-ai:hover .icon {
+    color: #ffffff;
+  }
+  
+  .floating-home .title, .floating-ai .title {
     position: absolute;
     left: 70px;
     background: rgba(255, 255, 255, 0.95);
@@ -928,7 +1227,7 @@ HTML = """
     transition: all 0.3s ease;
   }
   
-  .floating-home:hover .title {
+  .floating-home:hover .title, .floating-ai:hover .title {
     opacity: 1;
     transform: translateX(0);
   }
@@ -1472,6 +1771,257 @@ HTML = """
     grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
   }
 
+  /* AI 챗봇 UI 스타일 */
+  #aiChatContainer {
+    display: none;
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: 400px;
+    height: 100%;
+    background: rgba(255, 255, 255, 0.95);
+    backdrop-filter: blur(10px);
+    box-shadow: -5px 0 20px rgba(0, 0, 0, 0.1);
+    z-index: 9999;
+    transition: all 0.3s ease;
+    transform: translateX(100%);
+    padding: 20px;
+    box-sizing: border-box;
+    display: flex;
+    flex-direction: column;
+  }
+  
+  #aiChatContainer.active {
+    transform: translateX(0);
+  }
+  
+  #aiChatHeader {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 15px;
+    padding-bottom: 15px;
+    border-bottom: 1px solid rgba(0, 0, 0, 0.1);
+  }
+  
+  #aiChatHeader h3 {
+    margin: 0;
+    color: #333;
+    font-size: 18px;
+    display: flex;
+    align-items: center;
+  }
+  
+  #aiChatHeader h3 i {
+    margin-right: 10px;
+    color: var(--ai-color);
+  }
+  
+  #aiChatClose {
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-size: 18px;
+    color: #666;
+    transition: var(--transition);
+  }
+  
+  #aiChatClose:hover {
+    color: #333;
+    transform: scale(1.1);
+  }
+  
+  #aiChatMessages {
+    flex: 1;
+    overflow-y: auto;
+    padding: 10px 0;
+    margin-bottom: 15px;
+  }
+  
+  .chat-message {
+    margin-bottom: 15px;
+    display: flex;
+    align-items: flex-start;
+  }
+  
+  .chat-message.user {
+    flex-direction: row-reverse;
+  }
+  
+  .chat-avatar {
+    width: 35px;
+    height: 35px;
+    border-radius: 50%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    margin-right: 10px;
+    flex-shrink: 0;
+  }
+  
+  .chat-message.user .chat-avatar {
+    margin-right: 0;
+    margin-left: 10px;
+    background: var(--primary-color);
+    color: white;
+  }
+  
+  .chat-message.ai .chat-avatar {
+    background: var(--ai-color);
+    color: white;
+  }
+  
+  .chat-content {
+    background: #f1f1f1;
+    padding: 12px 15px;
+    border-radius: 18px;
+    max-width: 75%;
+    word-break: break-word;
+    position: relative;
+    font-size: 14px;
+    line-height: 1.4;
+  }
+  
+  .chat-message.user .chat-content {
+    background: var(--primary-color);
+    color: white;
+    border-bottom-right-radius: 4px;
+  }
+  
+  .chat-message.ai .chat-content {
+    background: #f1f1f1;
+    color: #333;
+    border-bottom-left-radius: 4px;
+  }
+  
+  #aiChatForm {
+    display: flex;
+    border-top: 1px solid rgba(0, 0, 0, 0.1);
+    padding-top: 15px;
+  }
+  
+  #aiChatInput {
+    flex: 1;
+    padding: 12px 15px;
+    border: 1px solid #ddd;
+    border-radius: 25px;
+    font-size: 14px;
+    outline: none;
+    transition: var(--transition);
+  }
+  
+  #aiChatInput:focus {
+    border-color: var(--ai-color);
+    box-shadow: 0 0 0 2px rgba(134, 232, 171, 0.2);
+  }
+  
+  #aiChatSubmit {
+    background: var(--ai-color);
+    border: none;
+    color: white;
+    width: 45px;
+    height: 45px;
+    border-radius: 50%;
+    margin-left: 10px;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    cursor: pointer;
+    transition: var(--transition);
+  }
+  
+  #aiChatSubmit:hover {
+    background: var(--ai-hover);
+    transform: scale(1.05);
+  }
+  
+  #aiChatSubmit:disabled {
+    background: #ccc;
+    cursor: not-allowed;
+  }
+  
+  .typing-indicator {
+    display: flex;
+    align-items: center;
+    margin-top: 5px;
+    font-size: 12px;
+    color: #666;
+  }
+  
+  .typing-indicator span {
+    height: 8px;
+    width: 8px;
+    background: var(--ai-color);
+    border-radius: 50%;
+    display: inline-block;
+    margin-right: 3px;
+    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% { transform: translateY(0); }
+    50% { transform: translateY(-5px); }
+    100% { transform: translateY(0); }
+  }
+  
+  .chat-time {
+    font-size: 10px;
+    color: #999;
+    margin-top: 5px;
+    text-align: right;
+  }
+  
+  /* 코드 블록 스타일 */
+  .chat-content pre {
+    background: rgba(0, 0, 0, 0.05);
+    padding: 10px;
+    border-radius: 5px;
+    overflow-x: auto;
+    font-family: monospace;
+    font-size: 12px;
+    margin: 10px 0;
+  }
+  
+  /* 마크다운 스타일 */
+  .chat-content strong {
+    font-weight: bold;
+  }
+  
+  .chat-content em {
+    font-style: italic;
+  }
+  
+  .chat-content ul, .chat-content ol {
+    margin-left: 20px;
+    margin-top: 5px;
+    margin-bottom: 5px;
+  }
+  
+  /* 공유 버튼 */
+  #shareChat {
+    padding: 8px 15px;
+    background: #f1f1f1;
+    border: none;
+    border-radius: 20px;
+    font-size: 12px;
+    color: #666;
+    cursor: pointer;
+    margin-top: 5px;
+    transition: var(--transition);
+  }
+  
+  #shareChat:hover {
+    background: #ddd;
+  }
+
   /* 반응형 디자인 */
   @media (max-width: 768px) {
     .grid {
@@ -1488,12 +2038,12 @@ HTML = """
       padding: 10px 20px;
     }
     
-    .floating-home {
+    .floating-home, .floating-ai {
       width: 50px;
       height: 50px;
     }
     
-    .floating-home .icon {
+    .floating-home .icon, .floating-ai .icon {
       font-size: 18px;
     }
     
@@ -1501,6 +2051,10 @@ HTML = """
       padding: 6px 15px;
       font-size: 12px;
     }
+    
+    #aiChatContainer {
+      width: 100%;
+    }
   }
   </style>
 </head>
@@ -1511,6 +2065,25 @@ HTML = """
     <div class="title">홈으로 돌아가기</div>
   </div>
   
+  <!-- AI 버튼 추가 -->
+  <div id="aiButton" class="floating-ai" style="display:none;">
+    <div class="icon"><i class="fas fa-robot"></i></div>
+    <div class="title">AI 어시스턴트</div>
+  </div>
+  
+  <!-- AI 챗봇 컨테이너 -->
+  <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>
+  
   <!-- 관리자 버튼 -->
   <div id="adminButton">
     <i class="fas fa-cog"></i> Admin
@@ -1588,6 +2161,11 @@ HTML = """
     let audioInitialized = false;
     let audioContext = null;
 
+    // AI 챗봇 관련 변수
+    let isAiChatActive = false;
+    let isAiProcessing = false;
+    let hasLoadedSummary = false;
+
     // 오디오 초기화 함수
     function initializeAudio() {
       if (audioInitialized) return Promise.resolve();
@@ -1685,6 +2263,183 @@ HTML = """
     /* ── 유틸 ── */
     function $id(id){return document.getElementById(id)}
     
+    // 현재 시간을 포맷팅하는 함수
+    function formatTime() {
+      const now = new Date();
+      const hours = now.getHours().toString().padStart(2, '0');
+      const minutes = now.getMinutes().toString().padStart(2, '0');
+      return `${hours}:${minutes}`;
+    }
+    
+    // AI 챗봇 메시지 추가 함수
+    function addChatMessage(content, isUser = false) {
+      const messagesContainer = $id('aiChatMessages');
+      const messageElement = document.createElement('div');
+      messageElement.className = `chat-message ${isUser ? 'user' : 'ai'}`;
+      
+      const currentTime = formatTime();
+      
+      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">${currentTime}</div>
+        </div>
+      `;
+      
+      messagesContainer.appendChild(messageElement);
+      messagesContainer.scrollTop = messagesContainer.scrollHeight;
+      return messageElement;
+    }
+    
+    // 로딩 표시기 추가 함수
+    function addTypingIndicator() {
+      const messagesContainer = $id('aiChatMessages');
+      const indicatorElement = document.createElement('div');
+      indicatorElement.className = 'typing-indicator';
+      indicatorElement.innerHTML = `
+        <div class="chat-avatar">
+          <i class="fas fa-robot"></i>
+        </div>
+        <div>
+          <span></span>
+          <span></span>
+          <span></span>
+        </div>
+      `;
+      messagesContainer.appendChild(indicatorElement);
+      messagesContainer.scrollTop = messagesContainer.scrollHeight;
+      return indicatorElement;
+    }
+    
+    // AI 챗봇 토글 함수
+    function toggleAiChat(show = true) {
+      const aiChatContainer = $id('aiChatContainer');
+      
+      if (show) {
+        // 챗봇 표시
+        aiChatContainer.style.display = 'flex';
+        setTimeout(() => {
+          aiChatContainer.classList.add('active');
+        }, 10);
+        isAiChatActive = true;
+        
+        // 처음 열 때 자동 요약 로드
+        if (!hasLoadedSummary && currentPdfId) {
+          loadPdfSummary();
+        }
+      } else {
+        // 챗봇 숨기기
+        aiChatContainer.classList.remove('active');
+        setTimeout(() => {
+          aiChatContainer.style.display = 'none';
+        }, 300);
+        isAiChatActive = false;
+      }
+    }
+    
+    // PDF 요약 로드 함수
+// PDF 요약 로드 함수
+async function loadPdfSummary() {
+  if (!currentPdfId || isAiProcessing || hasLoadedSummary) return;
+  
+  try {
+    isAiProcessing = true;
+    const typingIndicator = addTypingIndicator();
+    
+    // 서버에 요약 요청
+    const response = await fetch(`/api/ai/summarize-pdf/${currentPdfId}`);
+    const data = await response.json();
+    
+    // 로딩 표시기 제거
+    typingIndicator.remove();
+    
+    if (data.error) {
+      // 오류 메시지 표시
+      addChatMessage(`PDF 요약을 생성하는 중 문제가 발생했습니다: ${data.error}<br><br>계속 질문을 입력하시면 PDF 내용을 기반으로 답변을 시도하겠습니다.`);
+      
+      // 요약이 실패해도 특정 경우에는 사용자에게 알리고 계속 사용 가능하도록 설정
+      if (data.summary) {
+        addChatMessage(`<strong>PDF에서 추출한 정보:</strong><br>${data.summary}`);
+        hasLoadedSummary = true;
+      }
+    } else {
+      // 환영 메시지와 요약 추가
+      addChatMessage(`안녕하세요! 이 PDF에 대해 어떤 것이든 질문해주세요. 제가 도와드리겠습니다.<br><br><strong>PDF 요약:</strong><br>${data.summary}`);
+      hasLoadedSummary = true;
+    }
+  } catch (error) {
+    console.error("PDF 요약 로드 오류:", error);
+    addChatMessage(`PDF 요약을 로드하는 중 오류가 발생했습니다. 서버 연결을 확인해주세요.<br><br>어떤 질문이든 입력하시면 최선을 다해 답변하겠습니다.`);
+  } finally {
+    isAiProcessing = false;
+  }
+}
+
+// 질문 제출 함수
+async function submitQuestion(question) {
+  if (!currentPdfId || isAiProcessing || !question.trim()) return;
+  
+  try {
+    isAiProcessing = true;
+    $id('aiChatSubmit').disabled = true;
+    
+    // 사용자 메시지 추가
+    addChatMessage(question, true);
+    
+    // 로딩 표시기 추가
+    const typingIndicator = addTypingIndicator();
+    
+    // 서버에 질의 요청
+    const response = await fetch(`/api/ai/query-pdf/${currentPdfId}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({ query: question }),
+      // 타임아웃 설정 추가
+      signal: AbortSignal.timeout(60000) // 60초 타임아웃
+    });
+    
+    const data = await response.json();
+    
+    // 로딩 표시기 제거
+    typingIndicator.remove();
+    
+    if (data.error) {
+      // 오류 메시지에 따라 다른 친절한 안내 제공
+      if (data.error.includes("API 키")) {
+        addChatMessage("죄송합니다. 현재 AI 서비스에 연결할 수 없습니다. 시스템 관리자에게 API 키 설정을 확인해달라고 요청해주세요.");
+      } else if (data.error.includes("연결")) {
+        addChatMessage("죄송합니다. AI 서비스에 연결할 수 없습니다. 인터넷 연결을 확인하거나 잠시 후 다시 시도해주세요.");
+      } else {
+        addChatMessage(`죄송합니다. 질문에 답변하는 중 문제가 발생했습니다: ${data.error}`);
+      }
+    } else {
+      // AI 응답 추가
+      addChatMessage(data.answer);
+    }
+  } catch (error) {
+    console.error("질문 제출 오류:", error);
+    if (error.name === 'AbortError') {
+      addChatMessage("죄송합니다. 응답 시간이 너무 오래 걸려 요청이 취소되었습니다. 인터넷 연결을 확인하거나 더 짧은 질문으로 다시 시도해보세요.");
+    } else {
+      addChatMessage("죄송합니다. 서버와 통신 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요.");
+    }
+  } finally {
+    isAiProcessing = false;
+    $id('aiChatSubmit').disabled = false;
+    $id('aiChatInput').value = '';
+    $id('aiChatInput').focus();
+  }
+}
+
+
+
+
+    
     // DOM이 로드되면 실행
     document.addEventListener('DOMContentLoaded', function() {
       console.log("DOM 로드 완료, 이벤트 설정 시작");
@@ -1746,6 +2501,40 @@ HTML = """
           $id('loadingPages').style.display = 'none';
           currentLoadingPdfPath = null;
           currentPdfId = null;
+          
+          // AI 챗봇 닫기
+          toggleAiChat(false);
+          hasLoadedSummary = false; // 요약 로드 상태 초기화
+        });
+      }
+      
+      // AI 버튼 이벤트 설정
+      const aiButton = document.getElementById('aiButton');
+      if (aiButton) {
+        aiButton.addEventListener('click', function() {
+          toggleAiChat(!isAiChatActive);
+        });
+      }
+      
+      // AI 챗봇 닫기 버튼
+      const aiChatClose = document.getElementById('aiChatClose');
+      if (aiChatClose) {
+        aiChatClose.addEventListener('click', function() {
+          toggleAiChat(false);
+        });
+      }
+      
+      // AI 챗봇 폼 제출
+      const aiChatForm = document.getElementById('aiChatForm');
+      if (aiChatForm) {
+        aiChatForm.addEventListener('submit', function(e) {
+          e.preventDefault();
+          const inputField = document.getElementById('aiChatInput');
+          const question = inputField.value.trim();
+          
+          if (question && !isAiProcessing) {
+            submitQuestion(question);
+          }
         });
       }
     });
@@ -2015,6 +2804,8 @@ HTML = """
                 createFlipBook(cachedData.pages);
                 // 현재 열린 PDF의 ID 저장
                 currentPdfId = pdfId;
+                // AI 버튼 표시
+                $id('aiButton').style.display = 'block';
                 return;
               }
             } catch (error) {
@@ -2054,6 +2845,8 @@ HTML = """
           
           // 현재 열린 PDF의 ID 저장
           currentPdfId = pdfId;
+          // AI 버튼 표시
+          $id('aiButton').style.display = 'block';
         }
       } catch (error) {
         console.error("PDF ID로 열기 실패:", error);
@@ -2092,10 +2885,19 @@ HTML = """
       const card = document.querySelectorAll('.card')[i];
       if (card && card.dataset.pdfId) {
         currentPdfId = card.dataset.pdfId;
+        // AI 버튼 표시
+        $id('aiButton').style.display = 'block';
       } else {
         currentPdfId = null;
+        // AI 버튼 숨김
+        $id('aiButton').style.display = 'none';
       }
       
+      // AI 챗봇 초기화
+      toggleAiChat(false);
+      hasLoadedSummary = false;
+      $id('aiChatMessages').innerHTML = '';
+      
       // 기존 FlipBook 정리
       if(fb) {
         fb.destroy();
@@ -2430,6 +3232,14 @@ HTML = """
       $id('homeButton').style.display=showHome?'none':'block';
       $id('adminPage').style.display='none';
       
+      // AI 버튼 관리
+      $id('aiButton').style.display = (!showHome && currentPdfId) ? 'block' : 'none';
+      
+      // AI 챗봇이 열려있으면 닫기
+      if (isAiChatActive) {
+        toggleAiChat(false);
+      }
+      
       // 뷰어 모드일 때 스타일 변경
       if(!showHome) {
         document.body.classList.add('viewer-mode');