Auto commit at 23-2025-08 3:51:46

lily_llm_api/app_v2.py

@@ -60,6 +60,9 @@ from lily_llm_core.hybrid_rag_processor import hybrid_rag_processor
 # 컨텍스트 관리자 및 LoRA 관리자 추가
 from lily_llm_core.context_manager import get_context_manager, context_manager
 
+# 계층적 메모리 시스템 추가
+from lily_llm_core.integrated_memory_manager import integrated_memory_manager
+
 # 전역 변수들
 current_model = None  # 🔄 현재 로드된 모델 인스턴스
 current_profile = None  # 🔄 현재 선택된 모델 프로필
@@ -491,7 +494,8 @@ def load_model_sync(model_id: str):
 
 def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_length: Optional[int] = None, 
                  temperature: Optional[float] = None, top_p: Optional[float] = None, 
-                 do_sample: Optional[bool] = None, use_context: bool = True, session_id: str = None) -> dict:
+                 do_sample: Optional[bool] = None, use_context: bool = True, session_id: str = None,
+                 user_id: str = "anonymous", room_id: str = "default") -> dict:
     """[최적화] 모델 생성을 처리하는 통합 동기 함수"""
     try:
         print(f"🔍 [DEBUG] generate_sync 시작 - prompt 길이: {len(prompt)}")
@@ -515,16 +519,24 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
         combined_image_metas = None
 
         # --- 1. 이미지 처리 (공식 방식) ---
-        if image_data_list and len([img for img in image_data_list if img]) > 0 and getattr(current_profile, 'multimodal', False):
-            print(f"🔍 [DEBUG] 이미지 처리 시작 - 이미지 개수: {len([img for img in image_data_list if img])}")
+        # 🔄 RAG에서 추출된 이미지 데이터도 포함
+        all_image_data = []
+        if image_data_list and len([img for img in image_data_list if img]) > 0:
+            all_image_data.extend(image_data_list)
+            print(f"🔍 [DEBUG] 직접 전달된 이미지 {len(image_data_list)}개 추가")
+        
+        # 🔄 RAG에서 추출된 이미지 데이터는 현재 구현에서 제거됨 (전역 변수 문제 해결)
+        
+        if all_image_data and len([img for img in all_image_data if img]) > 0 and getattr(current_profile, 'multimodal', False):
+            print(f"🔍 [DEBUG] 이미지 처리 시작 - 총 이미지 개수: {len([img for img in all_image_data if img])}")
             
             # 🔄 공식 방식: 간단한 이미지 처리
-            max_images = min(len(image_data_list), 4)
+            max_images = min(len(all_image_data), 4)
             logger.info(f"🖼️  멀티모달 처리 시작... (이미지 {max_images}개)")
             
             try:
                 metas_list = []
-                for idx, image_bytes in enumerate(image_data_list[:max_images]):
+                for idx, image_bytes in enumerate(all_image_data[:max_images]):
                     if image_bytes:
                         try:
                             pil_image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
@@ -568,31 +580,77 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
                 
                 # 2. RAG 검색 결과 컨텍스트 (PDF 내용 포함)
                 try:
-                    # 🔄 간단하고 직접적인 RAG 컨텍스트 로드
+                    # 🔄 새로운 메모리 시스템을 사용한 RAG 컨텍스트 로드
                     rag_context = ""
                     
-                    # 🔄 간단한 파일 기반 RAG 컨텍스트 로드
+                    # 통합 메모리 관리자에서 AI용 컨텍스트 생성
+                    ai_context = integrated_memory_manager.get_context_for_ai(
+                        user_id=user_id,
+                        room_id=room_id,
+                        session_id=session_id,
+                        include_user_memory=True,
+                        include_room_context=True,
+                        include_session_history=False  # 현재 대화는 별도로 처리
+                    )
+                    
+                    if ai_context:
+                        rag_context += f"\n\n🔗 메모리 컨텍스트:\n{ai_context}\n"
+                        print(f"🔍 [DEBUG] 메모리 컨텍스트 포함됨 - 길이: {len(ai_context)}")
+                    
+                    # 기존 RAG 시스템에서 문서 내용 가져오기 (room_id 기반)
                     try:
-                        # vector_stores 디렉토리에서 최근 문서 내용 직접 읽기
-                        import os
-                        import json
-                        
-                        vector_store_dir = "vector_stores"
-                        if os.path.exists(vector_store_dir):
-                            user_dirs = [d for d in os.listdir(vector_store_dir) if os.path.isdir(os.path.join(vector_store_dir, d))]
-                            if user_dirs:
-                                user_dir = user_dirs[0]  # 첫 번째 사용자
-                                user_path = os.path.join(vector_store_dir, user_dir)
+                        # 채팅방별 문서 컨텍스트 조회
+                        room_context = integrated_memory_manager.room_context_manager.get_room_context(room_id)
+                        if room_context and room_context.documents:
+                            rag_context += "\n\n📄 업로드된 문서 목록:\n"
+                            for doc in room_context.documents[-3:]:  # 최근 3개만
+                                # 딕셔너리와 객체 모두 처리
+                                if isinstance(doc, dict):
+                                    filename = doc.get('filename', 'unknown')
+                                    doc_type = doc.get('document_type', 'unknown')
+                                    page_count = doc.get('page_count', 0)
+                                else:
+                                    filename = getattr(doc, 'filename', 'unknown')
+                                    doc_type = getattr(doc, 'document_type', 'unknown')
+                                    page_count = getattr(doc, 'page_count', 0)
                                 
+                                rag_context += f"  - {filename} ({doc_type}, {page_count}페이지)\n"
+                            
+                            print(f"🔍 [DEBUG] 채팅방 {room_id}의 문서 {len(room_context.documents)}개 발견")
+                    
+                    except Exception as e:
+                        print(f"⚠️ 채팅방 문서 컨텍스트 로드 실패: {e}")
+                    
+                    # 새로운 메모리 시스템 기반 RAG 컨텍스트 로드
+                    try:
+                        # 현재 채팅방의 최신 문서 ID 사용
+                        room_context = integrated_memory_manager.room_context_manager.get_room_context(room_id)
+                        if room_context and room_context.documents:
+                            # 가장 최근에 업로드된 문서 사용
+                            latest_doc = room_context.documents[-1]
+                            
+                            # 딕셔너리와 객체 모두 처리
+                            if isinstance(latest_doc, dict):
+                                latest_doc_id = latest_doc.get('document_id', 'unknown')
+                                latest_user_id = latest_doc.get('uploaded_by', 'unknown')
+                            else:
+                                latest_doc_id = getattr(latest_doc, 'document_id', 'unknown')
+                                latest_user_id = getattr(latest_doc, 'uploaded_by', 'unknown')
+                            
+                            print(f"🔍 [DEBUG] 새로운 RAG 컨텍스트 검색: 채팅방={room_id}, 사용자={latest_user_id}, 문서={latest_doc_id}")
+                            
+                            # vector_stores 디렉토리에서 해당 문서 내용 읽기
+                            import os
+                            import json
+                            
+                            vector_store_dir = "vector_stores"
+                            if os.path.exists(vector_store_dir):
+                                user_path = os.path.join(vector_store_dir, latest_user_id)
                                 if os.path.exists(user_path):
-                                    doc_dirs = [d for d in os.listdir(user_path) if os.path.isdir(os.path.join(user_path, d))]
-                                    if doc_dirs:
-                                        # 최근 문서 ID 사용
-                                        recent_doc_id = doc_dirs[-1]
-                                        print(f"🔍 [DEBUG] RAG 컨텍스트 검색: 사용자={user_dir}, 문서={recent_doc_id}")
+                                    doc_path = os.path.join(user_path, latest_doc_id)
+                                    if os.path.exists(doc_path):
                                         
                                         # 문서 내용 파일 직접 읽기 (pickle 파일 지원)
-                                        doc_path = os.path.join(user_path, recent_doc_id)
                                         if os.path.exists(doc_path):
                                             # 🔄 pickle 파일에서 내용 읽기 (우선)
                                             pickle_file = os.path.join(doc_path, "simple_vector_store.pkl")
@@ -607,18 +665,64 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
                                                         documents_data = vector_store_data['documents']
                                                         if documents_data and len(documents_data) > 0:
                                                             rag_context = "\n\n📄 업로드된 문서 내용:\n"
+                                                            
+                                                            # 🚀 실무 수준 구조화된 PDF 데이터 처리
+                                                            extracted_images = []
                                                             for i, doc in enumerate(documents_data[:2]):  # 최대 2개 청크
                                                                 if hasattr(doc, 'page_content'):
                                                                     content = doc.page_content.strip()
                                                                     if content and len(content) > 30:
-                                                                        # 내용을 200자로 제한
-                                                                        truncated_content = content[:200] + "..." if len(content) > 200 else content
-                                                                        rag_context += f"--- 청크 {i+1} ---\n{truncated_content}\n\n"
+                                                                        # 구조화된 컨텐츠인지 확인
+                                                                        if "=== 페이지" in content and "[텍스트 블록" in content:
+                                                                            # 실무 수준 구조화된 컨텐츠
+                                                                            truncated_content = content[:400] + "..." if len(content) > 400 else content
+                                                                            rag_context += f"--- 구조화된 페이지 {i+1} ---\n{truncated_content}\n\n"
+                                                                            print(f"🚀 [DEBUG] 구조화된 PDF 페이지 데이터 로드됨")
+                                                                        else:
+                                                                            # 기존 방식
+                                                                            truncated_content = content[:200] + "..." if len(content) > 200 else content
+                                                                            rag_context += f"--- 청크 {i+1} ---\n{truncated_content}\n\n"
+                                                                    
+                                                                    # 🚀 구조화된 이미지 메타데이터 처리
+                                                                    if hasattr(doc, 'metadata') and doc.metadata:
+                                                                        metadata = doc.metadata
+                                                                        
+                                                                        # 실무 수준 구조화된 메타데이터 확인
+                                                                        if metadata.get('structured_analysis') and metadata.get('spatial_relationships'):
+                                                                            print(f"🚀 [DEBUG] 실무 수준 구조화된 메타데이터 발견")
+                                                                            
+                                                                            # 이미지 블록 정보 출력
+                                                                            if 'image_blocks' in metadata:
+                                                                                image_blocks = metadata['image_blocks']
+                                                                                for ib in image_blocks:
+                                                                                    print(f"🖼️ [DEBUG] 이미지 블록: {ib['block_id']}, "
+                                                                                          f"위치: ({ib['bbox']['x0']:.1f}, {ib['bbox']['y0']:.1f}), "
+                                                                                          f"관련 텍스트: {ib['related_text_count']}개")
+                                                                        
+                                                                        # 이미지 데이터 추출 (기존 방식 + 새로운 방식 모두 지원)
+                                                                        if metadata.get('multimodal_ready') and 'image_data_list' in metadata:
+                                                                            image_data_list = metadata['image_data_list']
+                                                                            if image_data_list and len(image_data_list) > 0:
+                                                                                extracted_images.extend(image_data_list)
+                                                                                print(f"🔍 [DEBUG] 청크 {i+1}에서 이미지 {len(image_data_list)}개 추출됨")
+                                                                                
+                                                                                # 이미지 메타데이터도 출력 (구조화된 경우)
+                                                                                if 'image_metadata' in metadata:
+                                                                                    for img_meta in metadata['image_metadata'][:2]:
+                                                                                        print(f"🖼️ [DEBUG] 이미지 상세: {img_meta['block_id']}, "
+                                                                                              f"크기: {img_meta['size']}, "
+                                                                                              f"관련 텍스트: {len(img_meta.get('related_texts', []))}개")
                                                             
                                                             if len(rag_context) > 30:
                                                                 context_prompt += rag_context
                                                                 print(f"🔍 [DEBUG] RAG 컨텍스트 포함됨 - 길이: {len(rag_context)}")
                                                                 print(f"🔍 [DEBUG] RAG 컨텍스트 미리보기: {rag_context[:100]}...")
+                                                                
+                                                                # 🔄 추출된 이미지가 있으면 로그 출력
+                                                                if extracted_images:
+                                                                    print(f"🔍 [DEBUG] 총 {len(extracted_images)}개 이미지 데이터 추출 완료")
+                                                                else:
+                                                                    print(f"🔍 [DEBUG] 추출된 이미지 없음")
                                                             else:
                                                                 print(f"⚠️ [DEBUG] RAG 컨텍스트가 너무 짧음: {len(rag_context)}")
                                                         else:
@@ -731,7 +835,7 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
         # --- 3. 토크나이징 ---
         print(f"🔍 [DEBUG] 토크나이징 시작")
         t_tok_start = time.time()
-        if not image_data_list or len([img for img in image_data_list if img]) == 0:
+        if not all_image_data or len([img for img in all_image_data if img]) == 0:
             # 텍스트-only 고정 경로 (더 빠름)
             print(f"🔍 [DEBUG] 텍스트-only 토크나이징 경로")
             print(f"🔍 [DEBUG] 사용할 프롬프트: {formatted_prompt}")
@@ -754,6 +858,7 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
             # 멀티모달(Lite): Kanana 전용 encode_prompt로 -1 토큰 자리 생성 (필수)
             print(f"🔍 [DEBUG] 멀티모달 토크나이징 경로")
             print(f"🔍 [DEBUG] combined_image_metas: {combined_image_metas}")
+            print(f"🔍 [DEBUG] 총 이미지 개수: {len(all_image_data)}")
             
             if hasattr(tokenizer, 'encode_prompt'):
                 print(f"🔍 [DEBUG] encode_prompt 메서드 사용")
@@ -1352,6 +1457,8 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
         total_time = time.time() - t_tok_start
         print(f"🔍 [DEBUG] 전체 처리 완료 - 총 소요시간: {total_time:.3f}초")
         
+        # 🔄 이미지 처리 완료 (전역 변수 초기화는 제거됨)
+        
         return {
             "generated_text": response,
             "processing_time": total_time,
@@ -1527,6 +1634,8 @@ async def generate(request: Request,
                   image2: UploadFile = File(None),
                   image3: UploadFile = File(None),
                   image4: UploadFile = File(None),
+                  user_id: str = Form("anonymous"),
+                  room_id: str = Form("default"),
                   use_context: bool = Form(True),
                   session_id: str = Form(None)):
     
@@ -1535,20 +1644,12 @@ async def generate(request: Request,
 
     start_time = time.time()
 
-    # 세션 ID가 없으면 자동 생성 (클라이언트별 고유 세션)
+    # 세션 ID가 없으면 자동 생성 (채팅방별 고유 세션)
     if not session_id:
-        # 클라이언트 IP 기반으로 고유한 세션 생성 (같은 클라이언트는 같은 세션 유지)
-        client_ip = "unknown"
-        try:
-            # Request 객체에서 클라이언트 IP 추출
-            client_ip = request.client.host if request.client else "unknown"
-        except:
-            pass
-        
-        # 클라이언트 IP + 시간 기반으로 세션 생성 (하루 동안 유지)
-        day_timestamp = int(time.time() // 86400) * 86400  # 하루 단위로 반올림
-        session_id = f"client_{client_ip}_{day_timestamp}"
-        print(f"🔍 [DEBUG] 자동 세션 ID 생성: {session_id} (클라이언트: {client_ip})")
+        # 채팅방 + 사용자 + 타임스탬프 기반으로 고유한 세션 생성
+        timestamp = int(time.time())
+        session_id = f"room_{room_id}_user_{user_id}_{timestamp}"
+        print(f"🔍 [DEBUG] 자동 세션 ID 생성: {session_id} (채팅방: {room_id}, 사용자: {user_id})")
     
     if use_context:
         context_manager.add_user_message(prompt, metadata={"session_id": session_id})
@@ -1566,7 +1667,7 @@ async def generate(request: Request,
 
     try:
         # generate_sync 함수 호출 (컨텍스트 포함)
-        result = generate_sync(prompt, image_data_list, use_context=use_context, session_id=session_id)
+        result = generate_sync(prompt, image_data_list, use_context=use_context, session_id=session_id, user_id=user_id, room_id=room_id)
         
         if "error" in result:
             raise HTTPException(status_code=500, detail=result["error"])
@@ -1716,6 +1817,7 @@ async def health_check():
 async def upload_document(
     file: UploadFile = File(...),
     user_id: str = Form("default_user"),  # 기본 사용자 ID
+    room_id: str = Form("default"),  # 채팅방 ID
     document_id: Optional[str] = Form(None)  # 문서 ID (자동 생성 가능)
 ):
     """문서 업로드 및 RAG 처리"""
@@ -1746,73 +1848,47 @@ async def upload_document(
         processing_time = time.time() - start_time
         logger.info(f"📄 문서 업로드 완료 ({processing_time:.2f}초): {file.filename}")
         
-        # 문서 업로드 후 자동으로 AI 응답 생성
+        # 새로운 메모리 시스템에 문서 정보 추가
         if result["success"]:
             try:
-                # 간단한 요약 질문으로 AI 응답 생성
-                summary_query = f"업로드된 문서 '{file.filename}'의 주요 내용을 요약해주세요."
+                # 문서 정보를 채팅방 컨텍스트에 추가
+                chunks = result.get("chunks", [])
+                chunk_count = len(chunks) if isinstance(chunks, list) else 0
                 
-                logger.info(f"🤖 문서 업로드 후 AI 응답 생성 시작...")
+                document_info = {
+                    "document_id": document_id,
+                    "filename": file.filename,
+                    "uploaded_by": user_id,
+                    "document_type": file.filename.split('.')[-1].lower() if '.' in file.filename else "unknown",
+                    "page_count": result.get("page_count", 0),
+                    "chunk_count": chunk_count,
+                    "summary": result.get("message", "")
+                }
+                
+                # 통합 메모리 관리자에 문서 추가
+                integrated_memory_manager.add_document_to_room(room_id, document_info)
+                
+                # 사용자 통계 업데이트
+                integrated_memory_manager.record_conversation(
+                    user_id, room_id, 
+                    topic=f"문서 업로드: {file.filename}"
+                )
+                
+                logger.info(f"✅ 메모리 시스템에 문서 정보 추가 완료: {room_id} - {file.filename}")
                 
-                # 🔄 RAG 시스템을 사용하여 문서 내용 기반 응답 생성
-                try:
-                    # RAG 검색을 통해 문서 내용을 포함한 프롬프트 생성
-                    summary_query = f"업로드된 문서 '{file.filename}'의 주요 내용을 요약해주세요."
-                    
-                    # RAG 응답 생성 (문서 내용 포함)
-                    rag_result = rag_processor.generate_rag_response(
-                        user_id, document_id, summary_query, llm_model=model
-                    )
-                    
-                    if rag_result["success"]:
-                        logger.info(f"✅ 자동 AI 응답 생성 완료: {len(rag_result['response'])} 문자")
-                        result["auto_response"] = rag_result["response"]
-                    else:
-                        logger.warning(f"⚠️ 자동 AI 응답 생성 실패: {rag_result.get('error', 'Unknown error')}")
-                        # 🔄 RAG 실패 시 generate_sync 사용 (fallback)
-                        if model and hasattr(model, 'generate'):
-                            try:
-                                from .app_v2 import generate_sync
-                                
-                                # 문서 내용을 포함한 프롬프트 생성
-                                context_prompt = f"""
-다음 문서의 내용을 바탕으로 요약해주세요:
-
-문서명: {file.filename}
-문서 ID: {document_id}
-
-문서 내용:
-{result.get('chunks', [])}
-
-위 문서의 주요 내용을 요약해주세요.
-"""
-                                
-                                response = generate_sync(
-                                    prompt=context_prompt,
-                                    image_data_list=None,
-                                    session_id=None
-                                )
-                                
-                                if response and "response" in response:
-                                    result["auto_response"] = response["response"]
-                                    logger.info(f"✅ fallback AI 응답 생성 완료: {len(response['response'])} 문자")
-                                else:
-                                    result["auto_response"] = "문서 요약을 생성할 수 없습니다."
-                                    logger.warning(f"⚠️ generate_sync 응답 형식 오류")
-                                    
-                            except Exception as e:
-                                logger.error(f"❌ fallback generate_sync 호출 실패: {e}")
-                                result["auto_response"] = "문서 요약 생성 중 오류가 발생했습니다."
-                        else:
-                            result["auto_response"] = "문서 요약을 생성할 수 없습니다."
-                    
-                except Exception as e:
-                    logger.error(f"❌ RAG 응답 생성 중 오류: {e}")
-                    result["auto_response"] = "문서 요약 생성 중 오류가 발생했습니다."
-                    
             except Exception as e:
-                logger.error(f"❌ 자동 AI 응답 생성 중 오류: {e}")
-                result["auto_response"] = "문서 요약 생성 중 오류가 발생했습니다."
+                logger.warning(f"⚠️ 메모리 시스템 업데이트 실패: {e}")
+        
+        # 문서 업로드 후 자동 AI 응답 생성 비활성화 (AI 리소스 절약)
+        # 사용자가 직접 질문할 때만 AI 응답 생성
+        auto_generate_response = False
+        
+        if result["success"]:
+            # 자동 AI 요약 없이 문서 업로드만 완료
+            result["auto_response"] = f"문서 '{file.filename}' 업로드 완료! 이제 질문해주세요."
+            logger.info(f"📄 자동 AI 응답 생성 건너뛰기 - AI 리소스 절약 (사용자 질문 시에만 AI 응답)")
+        else:
+            result["auto_response"] = "문서 업로드에 실패했습니다."
         
         return DocumentUploadResponse(
             success=result["success"],

lily_llm_core/document_processor.py

@@ -2,41 +2,34 @@
 """
 문서 처리 모듈
 PDF, DOCX, PPTX 등 다양한 문서 형식을 처리
+실무 수준 PDF 구조 분석 + 공간적 관계 매핑 지원
 """
 
 import os
 import logging
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Tuple, NamedTuple
 from pathlib import Path
 import easyocr
 import re
 import base64
 import io
+import json
+from dataclasses import dataclass, field
 
 # LangChain 문서 로더들
 try:
     from langchain_community.document_loaders import (
         PyMuPDFLoader,
         UnstructuredWordDocumentLoader,
-        UnstructuredPowerPointLoader,
-        UnstructuredFileLoader
+        UnstructuredPowerPointLoader
     )
-except ImportError as e:
-    logger.error(f"❌ LangChain 문서 로더 import 실패: {e}")
-    logger.error("pymupdf 패키지를 설치해주세요: pip install pymupdf")
-    raise
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.schema import Document
-
-# OCR imports
-try:
-    import easyocr
-    EASYOCR_AVAILABLE = True
+    from langchain.schema import Document
+    LANGCHAIN_AVAILABLE = True
 except ImportError:
-    EASYOCR_AVAILABLE = False
-    easyocr = None
+    LANGCHAIN_AVAILABLE = False
+    Document = None
 
-# Image processing imports
+# PIL (Pillow) 이미지 처리
 try:
     from PIL import Image, ImageEnhance
     PIL_AVAILABLE = True
@@ -47,48 +40,149 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
+# 실무 수준 PDF 구조 분석을 위한 데이터 클래스들
+@dataclass
+class BoundingBox:
+    """바운딩 박스 (x0, y0, x1, y1)"""
+    x0: float
+    y0: float
+    x1: float
+    y1: float
+    
+    @property
+    def width(self) -> float:
+        return self.x1 - self.x0
+    
+    @property
+    def height(self) -> float:
+        return self.y1 - self.y0
+    
+    @property
+    def center(self) -> Tuple[float, float]:
+        return ((self.x0 + self.x1) / 2, (self.y0 + self.y1) / 2)
+    
+    def overlaps_with(self, other: 'BoundingBox') -> bool:
+        """다른 박스와 겹치는지 확인"""
+        return not (self.x1 < other.x0 or other.x1 < self.x0 or 
+                   self.y1 < other.y0 or other.y1 < self.y0)
+    
+    def distance_to(self, other: 'BoundingBox') -> float:
+        """다른 박스와의 거리 (중심점 기준)"""
+        cx1, cy1 = self.center
+        cx2, cy2 = other.center
+        return ((cx1 - cx2) ** 2 + (cy1 - cy2) ** 2) ** 0.5
+
+@dataclass
+class PDFBlock:
+    """PDF의 텍스트/이미지 블록"""
+    block_id: str
+    block_type: str  # 'text', 'image', 'table', 'figure'
+    bbox: BoundingBox
+    content: Any
+    page_num: int
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def is_near(self, other: 'PDFBlock', threshold: float = 50.0) -> bool:
+        """다른 블록과 가까운지 확인 (픽셀 단위)"""
+        return self.bbox.distance_to(other.bbox) <= threshold
+    
+    def is_above(self, other: 'PDFBlock', threshold: float = 10.0) -> bool:
+        """다른 블록 위에 있는지 확인"""
+        return self.bbox.y1 <= other.bbox.y0 + threshold
+    
+    def is_below(self, other: 'PDFBlock', threshold: float = 10.0) -> bool:
+        """다른 블록 아래에 있는지 확인"""
+        return self.bbox.y0 >= other.bbox.y1 - threshold
+    
+    def is_left_of(self, other: 'PDFBlock', threshold: float = 10.0) -> bool:
+        """다른 블록 왼쪽에 있는지 확인"""
+        return self.bbox.x1 <= other.bbox.x0 + threshold
+    
+    def is_right_of(self, other: 'PDFBlock', threshold: float = 10.0) -> bool:
+        """다른 블록 오른쪽에 있는지 확인"""
+        return self.bbox.x0 >= other.bbox.x1 - threshold
+
+@dataclass
+class PDFPage:
+    """PDF 페이지 구조"""
+    page_num: int
+    width: float
+    height: float
+    blocks: List[PDFBlock] = field(default_factory=list)
+    
+    def get_blocks_by_type(self, block_type: str) -> List[PDFBlock]:
+        """특정 타입의 블록들 반환"""
+        return [block for block in self.blocks if block.block_type == block_type]
+    
+    def find_related_blocks(self, target_block: PDFBlock, 
+                          relation_types: List[str] = None) -> List[Tuple[PDFBlock, str]]:
+        """관련된 블록들과 관계 타입 반환"""
+        if relation_types is None:
+            relation_types = ['near', 'above', 'below', 'left', 'right']
+        
+        related = []
+        for block in self.blocks:
+            if block.block_id == target_block.block_id:
+                continue
+                
+            for relation in relation_types:
+                if relation == 'near' and target_block.is_near(block):
+                    related.append((block, 'near'))
+                elif relation == 'above' and target_block.is_above(block):
+                    related.append((block, 'above'))
+                elif relation == 'below' and target_block.is_below(block):
+                    related.append((block, 'below'))
+                elif relation == 'left' and target_block.is_left_of(block):
+                    related.append((block, 'left'))
+                elif relation == 'right' and target_block.is_right_of(block):
+                    related.append((block, 'right'))
+        
+        return related
+
+@dataclass
+class PDFStructure:
+    """PDF 전체 구조"""
+    pages: List[PDFPage] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def get_all_blocks(self) -> List[PDFBlock]:
+        """모든 블록 반환"""
+        all_blocks = []
+        for page in self.pages:
+            all_blocks.extend(page.blocks)
+        return all_blocks
+    
+    def get_blocks_by_type(self, block_type: str) -> List[PDFBlock]:
+        """전체 문서에서 특정 타입의 블록들 반환"""
+        blocks = []
+        for page in self.pages:
+            blocks.extend(page.get_blocks_by_type(block_type))
+        return blocks
+
 class DocumentProcessor:
     """문서 처리 클래스"""
     
     def __init__(self, formula_ocr_engine: str = 'easyocr'):
         """
+        문서 처리기 초기화
+        
         Args:
             formula_ocr_engine: 수식 추출 엔진 ('easyocr', 'mathpix', 'latexocr')
         """
         self.formula_ocr_engine = formula_ocr_engine
-        self.supported_formats = {
-            '.pdf': 'pdf',
-            '.docx': 'docx', 
-            '.doc': 'doc',
-            '.pptx': 'pptx',
-            '.ppt': 'ppt',
-            '.txt': 'text'
-        }
+        self.formula_extractor_available = False
         
-        # 텍스트 분할기 설정
-        self.text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=1000,
-            chunk_overlap=200,
-            length_function=len,
-            separators=["\n\n", "\n", " ", ""]
-        )
+        # 이미지 크기 제한 설정
+        self.min_image_size = (10, 10)      # 최소 이미지 크기 (너무 작은 이미지 제외)
+        self.max_image_size = (10000, 10000) # 최대 이미지 크기 (너무 큰 이미지 제외)
         
-        # OCR 리더 초기화 (한국어 + 영어 + 수학 기호 최적화)
-        if not EASYOCR_AVAILABLE:
-            logger.warning("⚠️ EasyOCR이 설치되지 않아 OCR 기능을 사용할 수 없습니다.")
+        # OCR 엔진 초기화
+        try:
+            self.ocr_reader = easyocr.Reader(['ko', 'en'], gpu=False)
+            logger.info("✅ EasyOCR 초기화 완료")
+        except Exception as e:
+            logger.warning(f"⚠️ EasyOCR 초기화 실패: {e}")
             self.ocr_reader = None
-        else:
-            try:
-                # 매우 기본적인 설정으로 단순화
-                self.ocr_reader = easyocr.Reader(
-                    ['ko', 'en'], 
-                    gpu=False, 
-                    verbose=True,  # 디버깅을 위해 verbose 활성화
-                )
-                logger.info("✅ OCR 리더 초기화 완료 (기본 설정)")
-            except Exception as e:
-                logger.error(f"❌ OCR 리더 초기화 실패: {e}")
-                self.ocr_reader = None
         
         # 수식 추출 엔진 설정 (LaTeX-OCR 비활성화됨)
         if formula_ocr_engine in ['mathpix']:  # 'latexocr' 제거
@@ -101,345 +195,57 @@ class DocumentProcessor:
                 logger.warning(f"⚠️ 수식 추출 엔진 {formula_ocr_engine} 사용 불가, EasyOCR로 대체")
         else:
             self.formula_extractor_available = False
-    
-    def get_file_type(self, file_path: str) -> Optional[str]:
-        """파일 타입 확인"""
-        try:
-            # 파일 경로에서 확장자 추출
-            file_path_str = str(file_path)
-            # Path 객체를 사용하여 확장자 추출
-            path_obj = Path(file_path_str)
-            extension = path_obj.suffix.lower()
-            
-            if extension:
-                # 🔄 확장자 앞의 점(.) 제거하여 반환
-                file_type = extension[1:] if extension.startswith('.') else extension
-                logger.info(f"📄 파일 확장자 인식: {extension} -> {file_type}")
-                return file_type
-            else:
-                logger.warning(f"⚠️ 파일 확장자를 찾을 수 없습니다: {file_path}")
-                return None
-        except Exception as e:
-            logger.error(f"❌ 파일 타입 확인 실패: {e}")
-            return None
-    
-    def extract_text_from_image(self, image_data: bytes) -> str:
-        """이미지에서 텍스트 추출 (OCR) - 수학 기호 최적화"""
-        if not self.ocr_reader:
-            logger.warning("⚠️ OCR 리더가 초기화되지 않았습니다.")
-            return ""
         
-        try:
-            import numpy as np
-            import io
-            
-            # 이미지 데이터를 PIL Image로 변환
-            pil_image = Image.open(io.BytesIO(image_data))
-            logger.info(f"📸 이미지 크기: {pil_image.size}")
-            
-            # 이미지 전처리 (수학 기호 인식 개선)
-            if PIL_AVAILABLE:
-                pil_image = self.preprocess_image_for_math(pil_image)
-                logger.info(f"📸 전처리 후 이미지 크기: {pil_image.size}")
-            
-            # PIL Image를 numpy 배열로 변환
-            img_array = np.array(pil_image)
-            logger.info(f"📸 numpy 배열 형태: {img_array.shape}")
-            
-            # OCR 실행 (기본 설정으로 단순화)
-            logger.info("🔍 OCR 실행 시작...")
-            results = self.ocr_reader.readtext(
-                img_array,
-                paragraph=True,  # 단락 단위로 처리
-            )
-            logger.info(f"🔍 OCR 결과 개수: {len(results)}")
-            
-            # 추출된 텍스트 결합 (신뢰도 기반 필터링)
-            extracted_text = ""
-            for i, result in enumerate(results):
-                try:
-                    # 결과 형식 확인 및 안전한 처리
-                    if len(result) == 3:
-                        bbox, text, confidence = result
-                    elif len(result) == 2:
-                        bbox, text = result
-                        confidence = 0.5  # 기본 신뢰도
-                    else:
-                        logger.warning(f"⚠️ 예상치 못한 OCR 결과 형식: {result}")
-                        continue
-                    
-                    logger.info(f"🔍 결과 {i+1}: '{text}' (신뢰도: {confidence:.2f})")
-                    
-                    if confidence > 0.3:  # 신뢰도 임계값을 30%로 낮춤
-                        # 수학 기호 후처리
-                        processed_text = self.post_process_math_symbols(text)
-                        extracted_text += processed_text + " "
-                    else:
-                        logger.info(f"⚠️ 신뢰도 낮음 제외: '{text}' (신뢰도: {confidence:.2f})")
-                        
-                except Exception as e:
-                    logger.warning(f"⚠️ OCR 결과 처리 실패 (결과 {i+1}): {e}")
-                    continue
-            
-            # LaTeX 수식 패턴 감지 및 정리
-            latex_patterns = [
-                r'\\[a-zA-Z]+',  # LaTeX 명령어
-                r'\\[a-zA-Z]+\{[^}]*\}',  # LaTeX 명령어 + 인수
-                r'\$[^$]+\$',  # 인라인 수식
-                r'\$\$[^$]+\$\$',  # 블록 수식
-                r'\\begin\{[^}]*\}.*?\\end\{[^}]*\}',  # 환경
-            ]
-            
-            latex_text = ""
-            for pattern in latex_patterns:
-                matches = re.findall(pattern, extracted_text)
-                if matches:
-                    latex_text += " ".join(matches) + "\n"
-            
-            # 최종 텍스트 구성
-            final_text = extracted_text.strip()
-            if latex_text.strip():
-                final_text += f"\n\n[LaTeX 수식 감지]\n{latex_text.strip()}"
-            
-            logger.info(f"✅ OCR 텍스트 추출 완료: {len(final_text)}자")
-            if len(final_text) == 0:
-                logger.warning("⚠️ OCR에서 텍스트를 추출하지 못했습니다.")
-            
-            return final_text
-            
-        except Exception as e:
-            logger.error(f"❌ OCR 텍스트 추출 실패: {e}")
-            return ""
+        logger.info(f"🚀 DocumentProcessor 초기화 완료 (OCR: {'EasyOCR' if self.ocr_reader else 'None'}, 수식: {formula_ocr_engine})")
     
-    def preprocess_image_for_math(self, image: Image.Image) -> Image.Image:
-        """수학 기호 인식을 위한 이미지 전처리 (단순화)"""
-        if not PIL_AVAILABLE:
-            logger.warning("⚠️ PIL이 설치되지 않아 이미지 전처리를 건너뜁니다.")
-            return image
-            
-        try:
-            # 기본적인 크기 조정만 수행
-            width, height = image.size
-            logger.debug(f"📸 원본 이미지 크기: {width}x{height}")
-            
-            # 너무 작은 이미지만 확대 (안정성 우선)
-            if width < 1000 or height < 1000:
-                scale_factor = max(1000 / width, 1000 / height)
-                new_width = int(width * scale_factor)
-                new_height = int(height * scale_factor)
-                image = image.resize((new_width, new_height), Image.LANCZOS)
-                logger.debug(f"📸 확대 후 이미지 크기: {new_width}x{new_height}")
-            
-            # 기본적인 대비 개선만 수행
-            try:
-                enhancer = ImageEnhance.Contrast(image)
-                image = enhancer.enhance(1.1)  # 대비 10% 증가 (낮춤)
-                logger.debug("📸 대비 개선 완료")
-            except Exception as e:
-                logger.debug(f"⚠️ 대비 개선 실패: {e}")
-            
-            return image
-            
-        except Exception as e:
-            logger.warning(f"⚠️ 이미지 전처리 실패: {e}")
-            return image
-    
-    def post_process_math_symbols(self, text: str) -> str:
-        """수학 기호 후처리"""
-        if not text:
-            return text
-        
-        # 수학 기호 매핑 (OCR 오인식 개선)
-        math_symbols = {
-            '@': '×',  # 곱하기 기호
-            '4': '=',  # 등호
-            '구': 'f',  # 함수 f
-            'B': 'β',  # 베타
-            'A': 'α',  # 알파
-            'C': 'γ',  # 감마
-            'D': 'δ',  # 델타
-            'E': 'ε',  # 엡실론
-            'F': 'φ',  # 파이
-            'G': 'γ',  # 감마
-            'H': 'η',  # 에타
-            'I': 'ι',  # 이오타
-            'K': 'κ',  # 카파
-            'L': 'λ',  # 람다
-            'M': 'μ',  # 뮤
-            'N': 'ν',  # 뉴
-            'O': 'ο',  # 오미크론
-            'P': 'π',  # 파이
-            'Q': 'θ',  # 세타
-            'R': 'ρ',  # 로
-            'S': 'σ',  # 시그마
-            'T': 'τ',  # 타우
-            'U': 'υ',  # 웁실론
-            'V': 'ω',  # 오메가
-            'W': 'ψ',  # 프사이
-            'X': 'χ',  # 카이
-            'Y': 'υ',  # 웁실론
-            'Z': 'ζ',  # 제타
-        }
-        
-        # 수학 기호 교체
-        for wrong, correct in math_symbols.items():
-            text = text.replace(wrong, correct)
-        
-        return text
-    
-    def post_process_ocr_text(self, text: str) -> str:
-        """OCR 결과 후처리 - 수학 기호 개선"""
-        if not text:
-            return text
-        
-        # 수학 기호 매핑 (OCR 오인식 개선)
-        math_symbols = {
-            '@': '×',  # 곱하기 기호
-            '4': '=',  # 등호
-            '구': 'f',  # 함수 f
-            'B': 'β',  # 베타
-            'A': 'α',  # 알파
-            'C': 'γ',  # 감마
-            'D': 'δ',  # 델타
-            'E': 'ε',  # 엡실론
-            'F': 'φ',  # 파이
-            'G': 'γ',  # 감마
-            'H': 'η',  # 에타
-            'I': 'ι',  # 이오타
-            'K': 'κ',  # 카파
-            'L': 'λ',  # 람다
-            'M': 'μ',  # 뮤
-            'N': 'ν',  # 뉴
-            'O': 'ο',  # 오미크론
-            'P': 'π',  # 파이
-            'Q': 'θ',  # 세타
-            'R': 'ρ',  # 로
-            'S': 'σ',  # 시그마
-            'T': 'τ',  # 타우
-            'U': 'υ',  # 웁실론
-            'V': 'ω',  # 오메가
-            'W': 'ψ',  # 프사이
-            'X': 'χ',  # 카이
-            'Y': 'υ',  # 웁실론
-            'Z': 'ζ',  # 제타
-            '0': 'θ',  # 세타 (숫자 0과 혼동)
-            '1': 'ι',  # 이오타 (숫자 1과 혼동)
-            '2': 'ζ',  # 제타 (숫자 2와 혼동)
-            '3': 'ξ',  # 크시 (숫자 3과 혼동)
-            '5': 'ς',  # 시그마 (숫자 5와 혼동)
-            '6': 'ς',  # 시그마 (숫자 6과 혼동)
-            '7': 'η',  # 에타 (숫자 7과 혼동)
-            '8': 'θ',  # 세타 (숫자 8과 혼동)
-            '9': 'ζ',  # 제타 (숫자 9와 혼동)
-        }
-        
-        # 수학 기호 교체
-        for wrong, correct in math_symbols.items():
-            text = text.replace(wrong, correct)
-        
-        # LaTeX 수식 패턴 감지 및 개선
-        latex_patterns = [
-            (r'f\s*\(\s*([^)]+)\s*\)', r'f(\1)'),  # 함수 표기 정리
-            (r'lim\s*([^→]+)→([^=]+)=', r'\\lim_{\1 \\to \2} ='),  # 극한 표기
-            (r'∫\s*([^d]+)d([^=]+)', r'\\int \1 d\2'),  # 적분 표기
-            (r'∑\s*([^=]+)=', r'\\sum \1 ='),  # 합 표기
-            (r'π', r'\\pi'),  # 파이
-            (r'∞', r'\\infty'),  # 무한대
-            (r'√([^=]+)', r'\\sqrt{\1}'),  # 제곱근
-            (r'([0-9]+)\^([0-9]+)', r'\1^{\\2}'),  # 지수
-            (r'([0-9]+)/([0-9]+)', r'\\frac{\1}{\2}'),  # 분수
-        ]
-        
-        for pattern, replacement in latex_patterns:
-            text = re.sub(pattern, replacement, text)
-        
-        return text
+    def get_file_type(self, file_path: str) -> str:
+        """파일 확장자 기반 파일 타입 반환"""
+        ext = Path(file_path).suffix.lower()
+        # 확장자에서 점 제거
+        return ext[1:] if ext.startswith('.') else ext
     
     def load_document(self, file_path: str) -> List[Document]:
-        """문서 로드 및 텍스트 추출"""
-        file_type = self.get_file_type(file_path)
-        if not file_type:
-            raise ValueError(f"지원하지 않는 파일 형식: {file_path}")
-        
-        documents = []
-        
+        """문서 로드 (기본 방식)"""
         try:
+            file_type = self.get_file_type(file_path)
+            
             if file_type == 'pdf':
-                # PDF 처리: 텍스트 직접 추출 방식으로 변경
-                import fitz  # PyMuPDF
-                
-                doc = fitz.open(file_path)
-                logger.info(f"📄 PDF 문서 로드: {len(doc)} 페이지")
-                
-                for page_num in range(len(doc)):
-                    page = doc.load_page(page_num)
-                    
-                    # 텍스트 직접 추출 (OCR 대신)
-                    page_text = page.get_text()
-                    
-                    # 텍스트가 비어있거나 너무 짧은 경우에만 OCR 사용
-                    if not page_text.strip() or len(page_text.strip()) < 50:
-                        logger.info(f"⚠️ 페이지 {page_num + 1} 텍스트 추출 실패, OCR 사용")
-                        pix = page.get_pixmap(dpi=300)
-                        img_data = pix.tobytes("png")
-                        page_text = self.extract_text_from_image(img_data)
-                        page_text = self.post_process_ocr_text(page_text)
-                    
-                    # 메타데이터 설정
-                    metadata = {
-                        'source': file_path,
-                        'page': page_num + 1,
-                        'file_type': 'pdf',
-                        'processing_method': 'text_extraction' if page_text.strip() else 'ocr'
-                    }
-                    
-                    # Document 객체 생성
-                    documents.append(Document(
-                        page_content=page_text,
-                        metadata=metadata
-                    ))
-                    
-                    logger.info(f"✅ 페이지 {page_num + 1} 처리 완료: {len(page_text)} 문자")
-                
-                doc.close()
-                logger.info(f"✅ PDF 문서 로드 완료: {len(documents)}개 페이지")
-                return documents
-                
+                loader = PyMuPDFLoader(file_path)
             elif file_type == 'docx':
                 loader = UnstructuredWordDocumentLoader(file_path)
-                documents = loader.load()
-                logger.info(f"✅ DOCX 문서 로드 완료: {len(documents)}개 청크")
-                
             elif file_type == 'pptx':
                 loader = UnstructuredPowerPointLoader(file_path)
-                documents = loader.load()
-                logger.info(f"✅ PPTX 문서 로드 완료: {len(documents)}개 청크")
-                
-            elif file_type == 'text':
-                loader = UnstructuredFileLoader(file_path)
-                documents = loader.load()
-                logger.info(f"✅ 텍스트 문서 로드 완료: {len(documents)}개 청크")
-                
             else:
-                raise ValueError(f"지원하지 않는 파일 형식: {file_type}")
-                
+                logger.warning(f"⚠️ 지원하지 않는 파일 형식: {file_type}")
+                return []
+            
+            documents = loader.load()
+            logger.info(f"📄 문서 로드 완료: {len(documents)}개 청크")
+            return documents
+            
         except Exception as e:
             logger.error(f"❌ 문서 로드 실패: {e}")
-            raise
-        
-        return documents
+            return []
     
-    def split_documents(self, documents: List[Document]) -> List[Document]:
+    def split_documents(self, documents: List[Document], chunk_size: int = 1000, chunk_overlap: int = 200) -> List[Document]:
         """문서를 청크로 분할"""
-        logger.info(f"📝 문서 분할 중: {len(documents)}개 문서")
-        
         try:
-            split_docs = self.text_splitter.split_documents(documents)
-            logger.info(f"✅ 문서 분할 완료: {len(split_docs)}개 청크")
+            from langchain.text_splitter import RecursiveCharacterTextSplitter
+            
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=chunk_size,
+                chunk_overlap=chunk_overlap,
+                length_function=len,
+                separators=["\n\n", "\n", " ", ""]
+            )
+            
+            split_docs = text_splitter.split_documents(documents)
+            logger.info(f"📄 문서 분할 완료: {len(documents)}개 → {len(split_docs)}개 청크")
             return split_docs
+            
         except Exception as e:
             logger.error(f"❌ 문서 분할 실패: {e}")
-            raise
+            return documents
     
     def process_document(self, file_path: str) -> List[Document]:
         """
@@ -457,8 +263,12 @@ class DocumentProcessor:
             file_type = self.get_file_type(file_path)
             
             if file_type == 'pdf':
-                # PDF는 하이브리드 방식으로 처리
-                return self._process_pdf_hybrid(file_path)
+                # PDF는 실무 수준 구조 분석으로 처리
+                pdf_structure = self._process_pdf_with_structure_analysis(file_path)
+                # PDFStructure를 Document 객체로 변환
+                documents = self._convert_structure_to_documents(pdf_structure)
+                logger.info(f"✅ 실무 수��� PDF 처리 완료: {len(documents)}개 Document 생성")
+                return documents
             else:
                 # 다른 문서 형식은 텍스트 기반 처리
                 documents = self.load_document(file_path)
@@ -488,156 +298,569 @@ class DocumentProcessor:
         except Exception as e:
             logger.error(f"❌ 문서 처리 실패: {e}")
             return []
-
+    
     def _process_pdf_hybrid(self, pdf_path: str) -> List[Document]:
         """
-        PDF 하이브리드 처리 (텍스트 + 이미지)
-        Cursor AI 방식: 텍스트 기반 + 이미지 포함 페이지는 이미지도 함께 처리
-        
-        Args:
-            pdf_path: PDF 파일 경로
-            
-        Returns:
-            List[Document]: 하이브리드 처리된 문서 청크들
+        실무 수준 PDF 처리 (구조 분석 + 공간적 관계 매핑)
+        """
+        return self._process_pdf_with_structure_analysis(pdf_path)
+    
+    def _process_pdf_with_structure_analysis(self, pdf_path: str) -> List[Document]:
+        """
+        실무 수준 PDF 처리 (구조 분석 + 공간적 관계 매핑)
         """
         try:
             import fitz  # PyMuPDF
             
             doc = fitz.open(pdf_path)
-            processed_docs = []
+            pdf_structure = PDFStructure()
+            
+            # PDF 경로 정보를 메타데이터에 추가
+            pdf_structure.metadata["source"] = pdf_path
             
-            logger.info(f"📄 PDF 하이브리드 처리 시작: {len(doc)}페이지")
+            logger.info(f"🔍 PDF 구조 분석 시작: {len(doc)}페이지")
             
             for page_num in range(len(doc)):
-                page = doc.load_page(page_num)
+                page = doc[page_num]
+                page_rect = page.rect
+                
+                pdf_page = PDFPage(
+                    page_num=page_num + 1,
+                    width=page_rect.width,
+                    height=page_rect.height
+                )
+                
+                # 1. 텍스트 블록 추출 (위치 정보 포함)
+                text_blocks = self._extract_text_blocks(page, page_num)
+                pdf_page.blocks.extend(text_blocks)
+                
+                # 2. 이미지 블록 추출 (위치 정보 포함)
+                image_blocks = self._extract_image_blocks(page, page_num, doc)
+                pdf_page.blocks.extend(image_blocks)
+                
+                pdf_structure.pages.append(pdf_page)
+                
+                logger.info(f"📄 페이지 {page_num + 1} 분석 완료: "
+                          f"텍스트 블록 {len(text_blocks)}개, "
+                          f"이미지 블록 {len(image_blocks)}개")
+            
+            doc.close()
+            
+            # 3. 블록 간 관계 분석
+            self._analyze_block_relationships(pdf_structure)
+            
+            logger.info(f"✅ PDF 구조 분석 완료: 총 {len(pdf_structure.get_all_blocks())}개 블록")
+            return pdf_structure
+            
+        except Exception as e:
+            logger.error(f"❌ PDF 구조 분석 실패: {e}")
+            import traceback
+            traceback.print_exc()
+            return PDFStructure()
+    
+    def _extract_text_blocks(self, page, page_num: int) -> List[PDFBlock]:
+        """페이지에서 텍스트 블록 추출"""
+        text_blocks = []
+        
+        try:
+            # PyMuPDF의 get_text("dict") 사용 - 가장 정확한 위치 정보 제공
+            text_dict = page.get_text("dict")
+            
+            for block_idx, block in enumerate(text_dict["blocks"]):
+                if "lines" not in block:  # 이미지 블록은 건너뛰기
+                    continue
                 
-                # 1. 텍스트 추출 시도
-                text_content = page.get_text()
+                # 블록의 바운딩 박스
+                bbox = BoundingBox(
+                    x0=block["bbox"][0],
+                    y0=block["bbox"][1], 
+                    x1=block["bbox"][2],
+                    y1=block["bbox"][3]
+                )
+                
+                # 텍스트 내용 추출
+                text_content = ""
+                for line in block["lines"]:
+                    for span in line["spans"]:
+                        text_content += span["text"]
+                    text_content += "\n"
                 
-                # 2. 이미지 추출
-                image_list = page.get_images()
-                page_images = []
+                text_content = text_content.strip()
                 
-                for img_index, img in enumerate(image_list):
-                    try:
-                        xref = img[0]
+                if text_content:  # 빈 텍스트 블록은 제외
+                    text_block = PDFBlock(
+                        block_id=f"page_{page_num + 1}_text_{block_idx}",
+                        block_type="text",
+                        bbox=bbox,
+                        content=text_content,
+                        page_num=page_num + 1,
+                        metadata={
+                            "font_info": self._extract_font_info(block),
+                            "word_count": len(text_content.split()),
+                            "char_count": len(text_content)
+                        }
+                    )
+                    text_blocks.append(text_block)
+        
+        except Exception as e:
+            logger.warning(f"⚠️ 페이지 {page_num + 1} 텍스트 블록 추출 실패: {e}")
+        
+        return text_blocks
+    
+    def _extract_image_blocks(self, page, page_num: int, doc=None) -> List[PDFBlock]:
+        """페이지에서 이미지 블록 추출"""
+        image_blocks = []
+        
+        try:
+            import fitz  # PyMuPDF
+            
+            # 1. 임베디드 이미지 추출
+            images = page.get_images()
+            
+            for img_idx, img_info in enumerate(images):
+                try:
+                    # 이미지 추출 - doc 객체를 직접 사용
+                    xref = img_info[0]
+                    if doc:
                         pix = fitz.Pixmap(doc, xref)
-                        
-                        if pix.n - pix.alpha < 4:  # CMYK 처리
+                    else:
+                        # fallback: 페이지에서 직접 추출 시도
+                        pix = page.get_pixmap()
+                        continue  # 이 경우는 건너뛰기
+                    
+                    if pix.n - pix.alpha < 4:  # GRAY or RGB
+                        if pix.colorspace and pix.colorspace.n > 3:
                             pix = fitz.Pixmap(fitz.csRGB, pix)
+                    
+                    img_data = pix.tobytes("png")
+                    img_pil = Image.open(io.BytesIO(img_data))
+                    
+                    if self._is_valid_image(img_pil):
+                        # 이미지의 위치 정보 추출 (중요!)
+                        img_rect = self._get_image_rect(page, xref)
                         
+                        if img_rect:
+                            bbox = BoundingBox(
+                                x0=img_rect.x0,
+                                y0=img_rect.y0,
+                                x1=img_rect.x1,
+                                y1=img_rect.y1
+                            )
+                            
+                            image_block = PDFBlock(
+                                block_id=f"page_{page_num + 1}_image_{img_idx}",
+                                block_type="image",
+                                bbox=bbox,
+                                content=img_data,  # 바이너리 데이터
+                                page_num=page_num + 1,
+                                metadata={
+                                    "image_size": img_pil.size,
+                                    "image_format": "PNG",
+                                    "image_mode": img_pil.mode,
+                                    "xref": xref,
+                                    "is_embedded": True
+                                }
+                            )
+                            image_blocks.append(image_block)
+                            
+                            logger.debug(f"🖼️ 이미지 블록 추출: 페이지 {page_num + 1}, "
+                                       f"위치 ({bbox.x0:.1f}, {bbox.y0:.1f}, {bbox.x1:.1f}, {bbox.y1:.1f}), "
+                                       f"크기 {img_pil.size}")
+                    
+                    pix = None
+                
+                except Exception as e:
+                    logger.warning(f"⚠️ 이미지 {img_idx} 처리 실패: {e}")
+            
+            # 2. 이미지가 없으면 전체 페이지 렌더링 (fallback)
+            if not image_blocks:
+                # 현재 모델이 멀티모달인지 확인
+                try:
+                    from lily_llm_api.app_v2 import current_profile
+                    is_multimodal = hasattr(current_profile, 'multimodal') and current_profile.multimodal
+                    
+                    if is_multimodal:
+                        # 전체 페이지를 이미지로 렌더링
+                        pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))  # 2배 해상도
                         img_data = pix.tobytes("png")
-                        img_pil = Image.open(io.BytesIO(img_data))
                         
-                        if self._is_valid_image(img_pil):
-                            # 이미지를 Base64로 인코딩
-                            img_buffer = io.BytesIO()
-                            img_pil.save(img_buffer, format='PNG')
-                            img_base64 = base64.b64encode(img_buffer.getvalue()).decode()
-                            image_url = f"data:image/png;base64,{img_base64}"
-                            
-                            page_images.append({
-                                "index": img_index,
-                                "image_url": image_url,
-                                "size": img_pil.size
-                            })
+                        bbox = BoundingBox(
+                            x0=0, y0=0,
+                            x1=page.rect.width,
+                            y1=page.rect.height
+                        )
                         
-                        pix = None
+                        image_block = PDFBlock(
+                            block_id=f"page_{page_num + 1}_fullpage",
+                            block_type="image",
+                            bbox=bbox,
+                            content=img_data,
+                            page_num=page_num + 1,
+                            metadata={
+                                "image_size": (pix.width, pix.height),
+                                "image_format": "PNG",
+                                "is_embedded": False,
+                                "is_full_page_render": True
+                            }
+                        )
+                        image_blocks.append(image_block)
                         
-                    except Exception as e:
-                        logger.warning(f"⚠️ 이미지 추출 실패 (페이지 {page_num + 1}, 인덱스 {img_index}): {e}")
-                        continue
+                        logger.debug(f"📄 전체 페이지 렌더링: 페이지 {page_num + 1}")
+                        pix = None
                 
-                # 3. 페이지별 문서 생성
-                if text_content.strip() or page_images:
-                    # 텍스트가 있거나 이미지가 있는 경우
-                    content_parts = []
-                    
-                    if text_content.strip():
-                        content_parts.append(f"[페이지 {page_num + 1}] {text_content.strip()}")
+                except ImportError:
+                    pass  # app_v2 import 실패 시 무시
+        
+        except Exception as e:
+            logger.warning(f"⚠️ 페이지 {page_num + 1} 이미지 블록 추출 실패: {e}")
+        
+        return image_blocks
+    
+    def _get_image_rect(self, page, xref: int) -> Optional[Any]:
+        """이미지의 실제 위치(rect) 찾기"""
+        try:
+            import fitz  # PyMuPDF
+            
+            # 페이지의 모든 이미지 참조에서 위치 찾기
+            for item in page.get_images(full=True):
+                if item[0] == xref:  # xref가 일치하면
+                    # 이미지가 사용된 위치 찾기
+                    image_list = page.get_image_info()
+                    for img_info in image_list:
+                        if img_info["xref"] == xref:
+                            return fitz.Rect(img_info["bbox"])
+            
+            # 대안: 페이지 내용에서 이미지 위치 검색
+            blocks = page.get_text("dict")["blocks"]
+            for block in blocks:
+                if block.get("type") == 1:  # 이미지 블록
+                    if block.get("xref") == xref:
+                        return fitz.Rect(block["bbox"])
+            
+            return None
+            
+        except Exception as e:
+            logger.debug(f"⚠️ 이미지 위치 찾기 실패: {e}")
+            return None
+    
+    def _extract_font_info(self, block: Dict) -> Dict[str, Any]:
+        """텍스트 블록에서 폰트 정보 추출"""
+        font_info = {
+            "fonts": [],
+            "sizes": [],
+            "flags": []
+        }
+        
+        try:
+            for line in block.get("lines", []):
+                for span in line.get("spans", []):
+                    font_info["fonts"].append(span.get("font", ""))
+                    font_info["sizes"].append(span.get("size", 0))
+                    font_info["flags"].append(span.get("flags", 0))
+            
+            # 중복 제거
+            font_info["fonts"] = list(set(font_info["fonts"]))
+            font_info["sizes"] = list(set(font_info["sizes"]))
+            font_info["flags"] = list(set(font_info["flags"]))
+            
+        except Exception as e:
+            logger.debug(f"⚠️ 폰트 정보 추출 실패: {e}")
+        
+        return font_info
+    
+    def _analyze_block_relationships(self, pdf_structure: PDFStructure):
+        """블록 간 관계 분석 및 메타데이터에 저장"""
+        
+        for page in pdf_structure.pages:
+            text_blocks = page.get_blocks_by_type("text")
+            image_blocks = page.get_blocks_by_type("image")
+            
+            # 각 이미지 블록에 대해 관련된 텍스트 블록 찾기
+            for image_block in image_blocks:
+                related_texts = []
+                
+                for text_block in text_blocks:
+                    # 공간적 관계 분석
+                    if image_block.is_near(text_block, threshold=100):  # 100픽셀 이내
+                        relation = self._determine_spatial_relationship(image_block, text_block)
+                        related_texts.append({
+                            "block_id": text_block.block_id,
+                            "relationship": relation,
+                            "distance": image_block.bbox.distance_to(text_block.bbox),
+                            "content_preview": text_block.content[:100] + "..." if len(text_block.content) > 100 else text_block.content
+                        })
+                
+                # 거리순으로 정렬
+                related_texts.sort(key=lambda x: x["distance"])
+                image_block.metadata["related_texts"] = related_texts[:3]  # 가장 가까운 3개만 저장
+                
+                logger.debug(f"🔗 이미지 블록 {image_block.block_id}에 "
+                           f"{len(related_texts)}개 텍스트 블록 연결")
+    
+    def _determine_spatial_relationship(self, block1: PDFBlock, block2: PDFBlock) -> str:
+        """두 블록 간의 공간적 관계 결정"""
+        if block1.is_above(block2):
+            return "above"
+        elif block1.is_below(block2):
+            return "below"
+        elif block1.is_left_of(block2):
+            return "left"
+        elif block1.is_right_of(block2):
+            return "right"
+        else:
+            return "near"
+    
+    def _convert_structure_to_documents(self, pdf_structure: PDFStructure) -> List[Document]:
+        """
+        PDF 구조를 Document 객체로 변환 (실무 수준 - 공간적 관계 포함)
+        """
+        documents = []
+        
+        try:
+            for page in pdf_structure.pages:
+                text_blocks = page.get_blocks_by_type("text")
+                image_blocks = page.get_blocks_by_type("image")
+                
+                if not text_blocks and not image_blocks:
+                    continue  # 빈 페이지 건너뛰기
+                
+                # 페이지별 구조화된 컨텐츠 생성
+                page_content = self._build_structured_content(page, text_blocks, image_blocks)
+                
+                # 이미지 데이터 준비 (멀티모달 처리용)
+                image_data_list = []
+                image_metadata = []
+                
+                for img_block in image_blocks:
+                    image_data_list.append(img_block.content)  # 바이너리 데이터
+                    image_metadata.append({
+                        "block_id": img_block.block_id,
+                        "bbox": {
+                            "x0": img_block.bbox.x0, "y0": img_block.bbox.y0,
+                            "x1": img_block.bbox.x1, "y1": img_block.bbox.y1
+                        },
+                        "size": img_block.metadata.get("image_size"),
+                        "related_texts": img_block.metadata.get("related_texts", [])
+                    })
+                
+                # Document 메타데이터 구성
+                metadata = {
+                    "source": pdf_structure.metadata.get("source", "unknown"),
+                    "page": page.page_num,
+                    "total_pages": len(pdf_structure.pages),
+                    "has_text": len(text_blocks) > 0,
+                    "has_images": len(image_blocks) > 0,
+                    "text_block_count": len(text_blocks),
+                    "image_block_count": len(image_blocks),
+                    "page_width": page.width,
+                    "page_height": page.height,
                     
-                    if page_images:
-                        content_parts.append(f"[이미지 {len(page_images)}개 포함]")
+                    # 실무 수준 메타데이터
+                    "structured_analysis": True,
+                    "spatial_relationships": True,
                     
-                    page_content = "\n\n".join(content_parts)
+                    # 멀티모달 처리용 데이터
+                    "multimodal_ready": len(image_blocks) > 0,
+                    "image_data_list": image_data_list,
+                    "image_metadata": image_metadata,
                     
-                    # 메타데이터 구성
-                    metadata = {
-                        "source": pdf_path,
-                        "page": page_num + 1,
-                        "total_pages": len(doc),
-                        "has_text": bool(text_content.strip()),
-                        "has_images": bool(page_images),
-                        "image_count": len(page_images)
-                    }
+                    # 블록 구조 정보
+                    "text_blocks": [
+                        {
+                            "block_id": tb.block_id,
+                            "bbox": {"x0": tb.bbox.x0, "y0": tb.bbox.y0, "x1": tb.bbox.x1, "y1": tb.bbox.y1},
+                            "word_count": tb.metadata.get("word_count", 0),
+                            "content_preview": tb.content[:50] + "..." if len(tb.content) > 50 else tb.content
+                        }
+                        for tb in text_blocks
+                    ],
+                    "image_blocks": [
+                        {
+                            "block_id": ib.block_id,
+                            "bbox": {"x0": ib.bbox.x0, "y0": ib.bbox.y0, "x1": ib.bbox.x1, "y1": ib.bbox.y1},
+                            "size": ib.metadata.get("image_size"),
+                            "related_text_count": len(ib.metadata.get("related_texts", []))
+                        }
+                        for ib in image_blocks
+                    ]
+                }
+                
+                # Document 객체 생성
+                doc = Document(
+                    page_content=page_content,
+                    metadata=metadata
+                )
+                documents.append(doc)
+                
+                logger.info(f"📄 페이지 {page.page_num} Document 생성: "
+                          f"텍스트 블록 {len(text_blocks)}개, 이미지 블록 {len(image_blocks)}개")
+        
+        except Exception as e:
+            logger.error(f"❌ PDF 구조 → Document 변환 실패: {e}")
+            import traceback
+            traceback.print_exc()
+        
+        return documents
+    
+    def _build_structured_content(self, page: PDFPage, text_blocks: List[PDFBlock], 
+                                image_blocks: List[PDFBlock]) -> str:
+        """
+        페이지의 구조화된 컨텐츠 생성 (공간적 관계 기반)
+        """
+        content_parts = []
+        
+        # 페이지 헤더
+        content_parts.append(f"=== 페이지 {page.page_num} ===")
+        
+        # 텍스트 블록들을 Y 좌표 순으로 정렬 (위에서 아래로)
+        sorted_text_blocks = sorted(text_blocks, key=lambda b: b.bbox.y0)
+        
+        # 이미지-텍스트 관계를 고려한 컨텐츠 구성
+        processed_images = set()
+        
+        for text_block in sorted_text_blocks:
+            # 1. 텍스트 블록 추가
+            content_parts.append(f"\n[텍스트 블록 {text_block.block_id}]")
+            content_parts.append(text_block.content)
+            
+            # 2. 이 텍스트 블록과 관련된 이미지 찾기
+            related_images = []
+            for img_block in image_blocks:
+                if img_block.block_id in processed_images:
+                    continue
                     
-                    # 이미지가 있는 경우 이미지 URL들 추가
-                    if page_images:
-                        metadata["image_urls"] = [img["image_url"] for img in page_images]
-                        metadata["image_sizes"] = [img["size"] for img in page_images]
+                # 공간적으로 가까운 이미지 찾기
+                if text_block.is_near(img_block, threshold=150):
+                    related_images.append(img_block)
+            
+            # 3. 관련된 이미지들을 거리순으로 정렬하여 추가
+            if related_images:
+                related_images.sort(key=lambda img: text_block.bbox.distance_to(img.bbox))
+                
+                for img_block in related_images[:2]:  # 최대 2개 이미지만
+                    relationship = self._determine_spatial_relationship(text_block, img_block)
+                    content_parts.append(f"\n[이미지 {img_block.block_id} - {relationship} 관계]")
+                    content_parts.append(f"이미지 크기: {img_block.metadata.get('image_size', 'unknown')}")
                     
-                    doc_chunk = Document(
-                        page_content=page_content,
-                        metadata=metadata
-                    )
-                    processed_docs.append(doc_chunk)
+                    # 관련 텍스트 정보 추가
+                    related_texts = img_block.metadata.get("related_texts", [])
+                    if related_texts:
+                        content_parts.append("관련 텍스트:")
+                        for rt in related_texts[:2]:  # 최대 2개만
+                            content_parts.append(f"  - {rt['relationship']}: {rt['content_preview']}")
                     
-                    logger.info(f"✅ 페이지 {page_num + 1} 처리 완료: 텍스트={bool(text_content.strip())}, 이미지={len(page_images)}개")
-                else:
-                    # 빈 페이지는 건너뛰기
-                    logger.info(f"⏭️ 페이지 {page_num + 1} 건너뛰기 (빈 페이지)")
-            
-            doc.close()
-            
-            if not processed_docs:
-                logger.warning("⚠️ 처리된 문서가 없습니다. 플레이스홀더를 추가합니다.")
-                placeholder_doc = Document(
-                    page_content="PDF 문서에서 내용을 추출할 수 없습니다.",
-                    metadata={"source": pdf_path, "page": 0}
-                )
-                processed_docs = [placeholder_doc]
-            
-            logger.info(f"✅ PDF 하이브리드 처리 완료: {len(processed_docs)}개 청크")
-            return processed_docs
-            
-        except Exception as e:
-            logger.error(f"❌ PDF 하이브리드 처리 실패: {e}")
-            # 실패 시 기존 텍스트 기반 처리로 폴백
-            logger.info("🔄 텍스트 기반 처리로 폴백합니다.")
-            return self.load_document(pdf_path)
-
+                    processed_images.add(img_block.block_id)
+        
+        # 4. 처리되지 않은 이미지들 추가 (독립적인 이미지들)
+        unprocessed_images = [img for img in image_blocks if img.block_id not in processed_images]
+        if unprocessed_images:
+            content_parts.append(f"\n[독립적인 이미지들]")
+            for img_block in unprocessed_images:
+                content_parts.append(f"\n[이미지 {img_block.block_id}]")
+                content_parts.append(f"이미지 크기: {img_block.metadata.get('image_size', 'unknown')}")
+                content_parts.append(f"위치: ({img_block.bbox.x0:.1f}, {img_block.bbox.y0:.1f})")
+        
+        # 5. 요약 정보 추가
+        content_parts.append(f"\n[페이지 {page.page_num} 요약]")
+        content_parts.append(f"텍스트 블록: {len(text_blocks)}개")
+        content_parts.append(f"이미지 블록: {len(image_blocks)}개")
+        content_parts.append(f"페이지 크기: {page.width:.1f} x {page.height:.1f}")
+        
+        return "\n".join(content_parts)
+    
     def _is_valid_image(self, img: Image.Image) -> bool:
         """이미지 유효성 검사"""
         try:
+            logger.debug(f"🔍 이미지 유효성 검사: 크기={img.size}, 모드={img.mode}")
+            
             # 최소/최대 크기 확인
             if img.size[0] < self.min_image_size[0] or img.size[1] < self.min_image_size[1]:
+                logger.debug(f"❌ 이미지 크기가 너무 작음: {img.size} < {self.min_image_size}")
                 return False
             if img.size[0] > self.max_image_size[0] or img.size[1] > self.max_image_size[1]:
+                logger.debug(f"❌ 이미지 크기가 너무 큼: {img.size} > {self.max_image_size}")
                 return False
             
             # 이미지 모드 확인
             if img.mode not in ['RGB', 'RGBA', 'L']:
+                logger.debug(f"❌ 지원하지 않는 이미지 모드: {img.mode}")
                 return False
             
+            logger.debug(f"✅ 이미지 유효성 검사 통과: {img.size}, {img.mode}")
             return True
-        except Exception:
+        except Exception as e:
+            logger.debug(f"❌ 이미지 유효성 검사 실패: {e}")
             return False
     
+    def _extract_text_from_image(self, img: Image.Image) -> str:
+        """이미지에서 텍스트 추출 (OCR)"""
+        try:
+            # EasyOCR 우선 시도
+            if self.ocr_reader:
+                try:
+                    result = self.ocr_reader.readtext(img)
+                    if result:
+                        text = " ".join([item[1] for item in result])
+                        logger.info(f"✅ EasyOCR로 텍스트 추출 성공: {len(text)}자")
+                        return text
+                except Exception as e:
+                    logger.warning(f"⚠️ EasyOCR 실패: {e}")
+            
+            # Tesseract fallback
+            try:
+                import pytesseract
+                # 그레이스케일 변환 (Tesseract 최적화)
+                if img.mode != 'L':
+                    img_gray = img.convert('L')
+                else:
+                    img_gray = img
+                
+                text = pytesseract.image_to_string(img_gray, lang='kor+eng')
+                if text and text.strip():
+                    logger.info(f"✅ Tesseract로 텍스트 추출 성공: {len(text.strip())}자")
+                    return text.strip()
+                else:
+                    logger.info("🔍 Tesseract OCR 결과 없음")
+                    return ""
+                    
+            except ImportError:
+                logger.warning("⚠️ pytesseract가 설치되지 않음")
+                return ""
+            except Exception as e:
+                logger.warning(f"⚠️ Tesseract OCR 실패: {e}")
+                return ""
+                
+        except Exception as e:
+            logger.error(f"❌ 이미지 OCR 전체 실패: {e}")
+            return ""
+    
     def _extract_formulas_from_documents(self, documents: List[Document]) -> List[Document]:
-        """
-        문서에서 수식을 추출하여 메타데이터에 추가
-        """
-        # 기존 구현 유지
+        """문서에서 수식 추출 (현재 비활성화됨)"""
+        # 수식 추출 기능은 현재 비활성화
         return documents
     
     def get_document_info(self, file_path: str) -> Dict[str, Any]:
-        """문서 정보 반환"""
+        """문서 정보 조회"""
         try:
-            documents = self.load_document(file_path)
+            if not os.path.exists(file_path):
+                return {'supported': False, 'error': '파일이 존재하지 않습니다.'}
+            
+            file_type = self.get_file_type(file_path)
+            
+            if file_type not in ['pdf', 'docx', 'pptx']:
+                return {'supported': False, 'error': f'지원하지 않는 파일 형식: {file_type}'}
+            
+            # 문서 로드 시도
+            documents = self.process_document(file_path)
+            
+            if not documents:
+                return {'supported': False, 'error': '문서 내용을 추출할 수 없습니다.'}
             
+            # 통계 정보 수집
             total_text = ""
             for doc in documents:
-                total_text += doc.page_content + "\n"
+                if hasattr(doc, 'page_content'):
+                    total_text += doc.page_content + " "
             
             return {
                 'file_path': file_path,
@@ -659,4 +882,4 @@ class DocumentProcessor:
 document_processor = DocumentProcessor(formula_ocr_engine='latexocr')
 # 필요시 다른 엔진으로 변경 가능:
 # document_processor = DocumentProcessor(formula_ocr_engine='easyocr')  # EasyOCR 사용
-# document_processor = DocumentProcessor(formula_ocr_engine='mathpix')  # MathPix API 사용 
+# document_processor = DocumentProcessor(formula_ocr_engine='mathpix')  # MathPix API 사용

lily_llm_core/integrated_memory_manager.py

@@ -0,0 +1,404 @@
+#!/usr/bin/env python3
+"""
+통합 메모리 관리자 (Integrated Memory Manager)
+계층적 메모리 시스템을 통합 관리하는 중앙 관리자
+"""
+
+import logging
+import time
+from typing import Dict, Any, List, Optional, Tuple
+from dataclasses import dataclass
+
+from .user_memory_manager import user_memory_manager, UserMemory
+from .room_context_manager import room_context_manager, RoomContext
+from .context_manager import AdvancedContextManager
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class MemoryContext:
+    """메모리 컨텍스트 통합 데이터"""
+    # 사용자 정보
+    user_id: str
+    user_memory: UserMemory
+    
+    # 채팅방 정보
+    room_id: str
+    room_context: RoomContext
+    
+    # 세션 정보
+    session_id: str
+    
+    # 통합 컨텍스트
+    combined_context: str = ""
+    memory_summary: str = ""
+
+class IntegratedMemoryManager:
+    """계층적 메모리 시스템 통합 관리자"""
+    
+    def __init__(self):
+        self.user_memory_manager = user_memory_manager
+        self.room_context_manager = room_context_manager
+        
+        # 세션별 컨텍스트 관리자
+        self.session_context_managers: Dict[str, AdvancedContextManager] = {}
+        
+        logger.info("🚀 IntegratedMemoryManager 초기화 완료")
+    
+    def get_memory_context(self, user_id: str, room_id: str, session_id: str) -> MemoryContext:
+        """통합 메모리 컨텍스트 조회"""
+        try:
+            # 1. 사용자 메모리 조회
+            user_memory = self.user_memory_manager.get_user_memory(user_id)
+            
+            # 2. 채팅방 컨텍스트 조회
+            room_context = self.room_context_manager.get_room_context(room_id)
+            
+            # 3. 세션별 컨텍스트 관리자 확인/생성
+            if session_id not in self.session_context_managers:
+                self.session_context_managers[session_id] = AdvancedContextManager(
+                    max_tokens=2000,
+                    max_turns=20,
+                    strategy="sliding_window"
+                )
+            
+            # 4. 통합 컨텍스트 생성
+            combined_context = self._create_combined_context(
+                user_memory, room_context, session_id
+            )
+            
+            # 5. 메모리 요약 생성
+            memory_summary = self._create_memory_summary(
+                user_memory, room_context
+            )
+            
+            return MemoryContext(
+                user_id=user_id,
+                user_memory=user_memory,
+                room_id=room_id,
+                room_context=room_context,
+                session_id=session_id,
+                combined_context=combined_context,
+                memory_summary=memory_summary
+            )
+            
+        except Exception as e:
+            logger.error(f"❌ 메모리 컨텍스트 조회 실패: {user_id}/{room_id}/{session_id} - {e}")
+            # 기본값 반환
+            return self._create_default_memory_context(user_id, room_id, session_id)
+    
+    def add_document_to_room(self, room_id: str, document_info: Dict[str, Any]) -> bool:
+        """채팅방에 문서 추가"""
+        try:
+            # 채팅방 컨텍스트에 문서 추가
+            success = self.room_context_manager.add_document(room_id, document_info)
+            
+            if success:
+                # 사용자 통계 업데이트
+                user_id = document_info.get("uploaded_by", "unknown")
+                if user_id != "unknown":
+                    self.user_memory_manager.record_conversation(
+                        user_id, 
+                        topic=f"문서 업로드: {document_info['filename']}"
+                    )
+                
+                logger.info(f"✅ 문서 추가 완료: {room_id} - {document_info['filename']}")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"❌ 문서 추가 실패: {room_id} - {e}")
+            return False
+    
+    def update_user_preferences(self, user_id: str, preferences: Dict[str, Any]) -> bool:
+        """사용자 선호도 업데이트"""
+        try:
+            success = self.user_memory_manager.update_preferences(user_id, preferences)
+            
+            if success:
+                logger.info(f"✅ 사용자 선호도 업데이트: {user_id} - {len(preferences)}개 항목")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"❌ 사용자 선호도 업데이트 실패: {user_id} - {e}")
+            return False
+    
+    def add_important_info(self, user_id: str, info: str) -> bool:
+        """사용자 중요 정보 추가"""
+        try:
+            success = self.user_memory_manager.add_important_info(user_id, info)
+            
+            if success:
+                logger.info(f"✅ 중요 정보 추가: {user_id} - {info[:50]}...")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"❌ 중요 정보 추가 실패: {user_id} - {e}")
+            return False
+    
+    def record_conversation(self, user_id: str, room_id: str, topic: str = None) -> bool:
+        """대화 기록 (통계 업데이트)"""
+        try:
+            # 사용자 통계 업데이트
+            user_success = self.user_memory_manager.record_conversation(user_id, topic)
+            
+            # 채팅방 통계 업데이트
+            room_success = self.room_context_manager.increment_message_count(room_id)
+            
+            # 참가자 추가
+            self.room_context_manager.add_participant(room_id, user_id)
+            
+            return user_success and room_success
+            
+        except Exception as e:
+            logger.error(f"❌ 대화 기록 실패: {user_id}/{room_id} - {e}")
+            return False
+    
+    def get_context_for_ai(self, user_id: str, room_id: str, session_id: str, 
+                          include_user_memory: bool = True,
+                          include_room_context: bool = True,
+                          include_session_history: bool = True) -> str:
+        """AI 응답 생성을 위한 통합 컨텍스트 생성"""
+        try:
+            context_parts = []
+            
+            # 1. 사용자 메모리 (전역 장기 기억)
+            if include_user_memory:
+                user_memory = self.user_memory_manager.get_user_memory(user_id)
+                user_context = self._format_user_memory_for_ai(user_memory)
+                if user_context:
+                    context_parts.append(f"=== 사용자 정보 ===\n{user_context}")
+            
+            # 2. 채팅방 컨텍스트 (중기 기억)
+            if include_room_context:
+                room_context = self.room_context_manager.get_room_context(room_id)
+                room_context_str = self._format_room_context_for_ai(room_context)
+                if room_context_str:
+                    context_parts.append(f"=== 채팅방 정보 ===\n{room_context_str}")
+            
+            # 3. 세션 히스토리 (초단기 기억)
+            if include_session_history and session_id in self.session_context_managers:
+                session_manager = self.session_context_managers[session_id]
+                session_context = session_manager.get_context(include_system=True, max_length=1000)
+                if session_context:
+                    context_parts.append(f"=== 현재 대화 ===\n{session_context}")
+            
+            # 통합 컨텍스트 생성
+            combined_context = "\n\n".join(context_parts)
+            
+            logger.debug(f"🔗 AI용 통합 컨텍스트 생성: {user_id}/{room_id}/{session_id} - {len(combined_context)} 문자")
+            return combined_context
+            
+        except Exception as e:
+            logger.error(f"❌ AI용 컨텍스트 생성 실패: {user_id}/{room_id}/{session_id} - {e}")
+            return ""
+    
+    def _create_combined_context(self, user_memory: UserMemory, 
+                                room_context: RoomContext, 
+                                session_id: str) -> str:
+        """통합 컨텍스트 생성"""
+        try:
+            context_parts = []
+            
+            # 사용자 기본 정보
+            if user_memory.name:
+                context_parts.append(f"사용자: {user_memory.name}")
+            
+            # 사용자 선호도
+            if user_memory.preferences:
+                prefs = ", ".join([f"{k}: {v}" for k, v in user_memory.preferences.items()])
+                context_parts.append(f"선호도: {prefs}")
+            
+            # 채팅방 정보
+            if room_context.room_name:
+                context_parts.append(f"채팅방: {room_context.room_name}")
+            
+            # 문서 정보
+            if room_context.documents:
+                doc_names = []
+                for d in room_context.documents[-3:]:
+                    if isinstance(d, dict):
+                        filename = d.get('filename', 'unknown')
+                    else:
+                        filename = getattr(d, 'filename', 'unknown')
+                    doc_names.append(filename)
+                
+                doc_info = f"문서 {len(room_context.documents)}개: " + ", ".join(doc_names)
+                context_parts.append(doc_info)
+            
+            return "\n".join(context_parts)
+            
+        except Exception as e:
+            logger.error(f"❌ 통합 컨텍스트 생성 실패: {e}")
+            return ""
+    
+    def _create_memory_summary(self, user_memory: UserMemory, 
+                              room_context: RoomContext) -> str:
+        """메모리 요약 생성"""
+        try:
+            summary_parts = []
+            
+            # 사용자 요약
+            if user_memory.important_info:
+                summary_parts.append(f"사용자 중요 정보: {len(user_memory.important_info)}개")
+            
+            if user_memory.expertise_areas:
+                summary_parts.append(f"전문 분야: {', '.join(user_memory.expertise_areas)}")
+            
+            # 채팅방 요약
+            if room_context.conversation_summary:
+                summary_parts.append(f"대화 요약: {room_context.conversation_summary[:100]}...")
+            
+            if room_context.key_topics:
+                summary_parts.append(f"주요 주제: {', '.join(room_context.key_topics)}")
+            
+            return " | ".join(summary_parts)
+            
+        except Exception as e:
+            logger.error(f"❌ 메모리 요약 생성 실패: {e}")
+            return ""
+    
+    def _format_user_memory_for_ai(self, user_memory: UserMemory) -> str:
+        """AI용 사용자 메모리 포맷팅"""
+        try:
+            parts = []
+            
+            if user_memory.name:
+                parts.append(f"이름: {user_memory.name}")
+            
+            if user_memory.important_info:
+                parts.append(f"중요 정보: {', '.join(user_memory.important_info)}")
+            
+            if user_memory.expertise_areas:
+                parts.append(f"전문 분야: {', '.join(user_memory.expertise_areas)}")
+            
+            if user_memory.interests:
+                parts.append(f"관심사: {', '.join(user_memory.interests)}")
+            
+            if user_memory.communication_style:
+                parts.append(f"대화 스타일: {user_memory.communication_style}")
+            
+            if user_memory.ai_personality:
+                parts.append(f"AI 성격: {user_memory.ai_personality}")
+            
+            return "\n".join(parts)
+            
+        except Exception as e:
+            logger.error(f"❌ 사용자 메모리 포맷팅 실패: {e}")
+            return ""
+    
+    def _format_room_context_for_ai(self, room_context: RoomContext) -> str:
+        """AI용 채팅방 컨텍스트 포맷팅"""
+        try:
+            parts = []
+            
+            if room_context.room_name:
+                parts.append(f"채팅방: {room_context.room_name}")
+            
+            if room_context.description:
+                parts.append(f"설명: {room_context.description}")
+            
+            if room_context.documents:
+                parts.append(f"업로드된 문서: {len(room_context.documents)}개")
+                for doc in room_context.documents[-3:]:  # 최근 3개만
+                    # 딕셔너리와 객체 모두 처리
+                    if isinstance(doc, dict):
+                        filename = doc.get('filename', 'unknown')
+                        doc_type = doc.get('document_type', 'unknown')
+                        page_count = doc.get('page_count', 0)
+                    else:
+                        filename = getattr(doc, 'filename', 'unknown')
+                        doc_type = getattr(doc, 'document_type', 'unknown')
+                        page_count = getattr(doc, 'page_count', 0)
+                    
+                    parts.append(f"  - {filename} ({doc_type}, {page_count}페이지)")
+            
+            if room_context.conversation_summary:
+                parts.append(f"대화 요약: {room_context.conversation_summary}")
+            
+            if room_context.key_topics:
+                parts.append(f"주요 주제: {', '.join(room_context.key_topics)}")
+            
+            return "\n".join(parts)
+            
+        except Exception as e:
+            logger.error(f"❌ 채팅방 컨텍스트 포맷팅 실패: {e}")
+            return ""
+    
+    def _create_default_memory_context(self, user_id: str, room_id: str, session_id: str) -> MemoryContext:
+        """기본 메모리 컨텍스트 생성 (오류 시)"""
+        try:
+            user_memory = self.user_memory_manager.get_user_memory(user_id)
+            room_context = self.room_context_manager.get_room_context(room_id)
+            
+            return MemoryContext(
+                user_id=user_id,
+                user_memory=user_memory,
+                room_id=room_id,
+                room_context=room_context,
+                session_id=session_id,
+                combined_context="",
+                memory_summary=""
+            )
+            
+        except Exception as e:
+            logger.error(f"❌ 기본 메모리 컨텍스트 생성 실패: {e}")
+            # 최소한의 기본값 반환
+            return MemoryContext(
+                user_id=user_id,
+                user_memory=None,
+                room_id=room_id,
+                room_context=None,
+                session_id=session_id,
+                combined_context="",
+                memory_summary=""
+            )
+    
+    def get_session_context_manager(self, session_id: str) -> AdvancedContextManager:
+        """세션별 컨텍스트 관리자 반환"""
+        if session_id not in self.session_context_managers:
+            self.session_context_managers[session_id] = AdvancedContextManager(
+                max_tokens=2000,
+                max_turns=20,
+                strategy="sliding_window"
+            )
+        
+        return self.session_context_managers[session_id]
+    
+    def cleanup_old_sessions(self, max_age_hours: int = 24):
+        """오래된 세션 정리"""
+        try:
+            current_time = time.time()
+            max_age_seconds = max_age_hours * 3600
+            
+            sessions_to_remove = []
+            
+            for session_id, manager in self.session_context_managers.items():
+                # 세션 ID에서 타임스탬프 추출 시도
+                try:
+                    # session_id 형식: room_{room_id}_user_{user_id}_{timestamp}
+                    if "_" in session_id:
+                        timestamp_str = session_id.split("_")[-1]
+                        timestamp = int(timestamp_str)
+                        
+                        if current_time - timestamp > max_age_seconds:
+                            sessions_to_remove.append(session_id)
+                
+                except (ValueError, IndexError):
+                    # 타임스탬프 추출 실패 시 건너뛰기
+                    continue
+            
+            # 오래된 세션 제거
+            for session_id in sessions_to_remove:
+                del self.session_context_managers[session_id]
+                logger.info(f"🗑️ 오래된 세션 정리: {session_id}")
+            
+            logger.info(f"✅ 세션 정리 완료: {len(sessions_to_remove)}개 제거")
+            
+        except Exception as e:
+            logger.error(f"❌ 세션 정리 실패: {e}")
+
+# 전역 인스턴스
+integrated_memory_manager = IntegratedMemoryManager()

lily_llm_core/room_context_manager.py

@@ -0,0 +1,374 @@
+#!/usr/bin/env python3
+"""
+채팅방별 컨텍스트 관리자 (Room Context Manager)
+채팅방별로 독립적인 대화 컨텍스트와 문서 히스토리를 관리
+"""
+
+import logging
+import time
+import json
+import os
+from typing import Dict, Any, List, Optional, Tuple
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from collections import deque
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class RoomDocument:
+    """채팅방에 업로드된 문서 정보"""
+    document_id: str
+    filename: str
+    uploaded_at: float
+    uploaded_by: str
+    document_type: str
+    page_count: int
+    chunk_count: int
+    summary: Optional[str] = None
+    tags: List[str] = None
+    
+    def __post_init__(self):
+        if self.tags is None:
+            self.tags = []
+
+@dataclass
+class RoomContext:
+    """채팅방별 컨텍스트 데이터"""
+    room_id: str
+    created_at: float
+    last_updated: float
+    
+    # 기본 정보
+    room_name: Optional[str] = None
+    description: Optional[str] = None
+    participants: List[str] = None
+    
+    # 문서 히스토리
+    documents: List[RoomDocument] = None
+    
+    # 대화 컨텍스트
+    conversation_summary: Optional[str] = None
+    key_topics: List[str] = None
+    total_messages: int = 0
+    
+    # AI 설정
+    ai_context: Dict[str, Any] = None
+    
+    def __post_init__(self):
+        if self.participants is None:
+            self.participants = []
+        if self.documents is None:
+            self.documents = []
+        if self.key_topics is None:
+            self.key_topics = []
+        if self.ai_context is None:
+            self.ai_context = {}
+
+class RoomContextManager:
+    """채팅방별 컨텍스트 관리자"""
+    
+    def __init__(self, storage_dir: str = "room_contexts"):
+        self.storage_dir = Path(storage_dir)
+        self.storage_dir.mkdir(exist_ok=True)
+        
+        # 컨텍스트 캐시
+        self.room_cache: Dict[str, RoomContext] = {}
+        self.cache_size_limit = 50  # 최대 50개 채팅방 캐시
+        
+        # 통계
+        self.total_rooms = 0
+        self.total_documents = 0
+        
+        logger.info(f"🚀 RoomContextManager 초기화: {self.storage_dir}")
+    
+    def get_room_context(self, room_id: str) -> RoomContext:
+        """채팅방 컨텍스트 조회 (캐시 우선)"""
+        # 캐시에서 먼저 확인
+        if room_id in self.room_cache:
+            logger.debug(f"📋 캐시에서 채팅방 컨텍스트 조회: {room_id}")
+            return self.room_cache[room_id]
+        
+        # 파일에서 로드
+        context = self._load_context_from_file(room_id)
+        if context:
+            # 캐시에 추가
+            self._add_to_cache(room_id, context)
+            return context
+        
+        # 새 컨텍스트 생성
+        context = self._create_new_context(room_id)
+        self._add_to_cache(room_id, context)
+        return context
+    
+    def add_document(self, room_id: str, document_info: Dict[str, Any]) -> bool:
+        """문서 추가"""
+        try:
+            context = self.get_room_context(room_id)
+            
+            # 새 문서 생성
+            document = RoomDocument(
+                document_id=document_info["document_id"],
+                filename=document_info["filename"],
+                uploaded_at=time.time(),
+                uploaded_by=document_info.get("uploaded_by", "unknown"),
+                document_type=document_info.get("document_type", "unknown"),
+                page_count=document_info.get("page_count", 0),
+                chunk_count=document_info.get("chunk_count", 0),
+                summary=document_info.get("summary"),
+                tags=document_info.get("tags", [])
+            )
+            
+            # 문서 추가
+            context.documents.append(document)
+            context.total_documents = len(context.documents)
+            context.last_updated = time.time()
+            
+            # 파일에 저장
+            self._save_context_to_file(context)
+            
+            logger.info(f"📄 문서 추가 완료: {room_id} - {document.filename}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 문서 추가 실패: {room_id} - {e}")
+            return False
+    
+    def get_documents(self, room_id: str) -> List[RoomDocument]:
+        """채팅방의 모든 문서 반환"""
+        try:
+            context = self.get_room_context(room_id)
+            return context.documents
+            
+        except Exception as e:
+            logger.error(f"❌ 문서 목록 조회 실패: {room_id} - {e}")
+            return []
+    
+    def find_document(self, room_id: str, document_id: str) -> Optional[RoomDocument]:
+        """특정 문서 찾기"""
+        try:
+            context = self.get_room_context(room_id)
+            
+            for doc in context.documents:
+                if doc.document_id == document_id:
+                    return doc
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"❌ 문서 검색 실패: {room_id} - {document_id} - {e}")
+            return None
+    
+    def update_conversation_summary(self, room_id: str, summary: str, topics: List[str] = None) -> bool:
+        """대화 요약 업데이트"""
+        try:
+            context = self.get_room_context(room_id)
+            
+            context.conversation_summary = summary
+            if topics:
+                context.key_topics = topics
+            
+            context.last_updated = time.time()
+            
+            self._save_context_to_file(context)
+            logger.info(f"📝 대화 요약 업데이트: {room_id} - {len(summary)} 문자")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 대화 요약 업데이트 실패: {room_id} - {e}")
+            return False
+    
+    def increment_message_count(self, room_id: str) -> bool:
+        """메시지 수 증가"""
+        try:
+            context = self.get_room_context(room_id)
+            context.total_messages += 1
+            context.last_updated = time.time()
+            
+            self._save_context_to_file(context)
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 메시지 수 증가 실패: {room_id} - {e}")
+            return False
+    
+    def add_participant(self, room_id: str, user_id: str) -> bool:
+        """참가자 추가"""
+        try:
+            context = self.get_room_context(room_id)
+            
+            if user_id not in context.participants:
+                context.participants.append(user_id)
+                context.last_updated = time.time()
+                
+                self._save_context_to_file(context)
+                logger.info(f"👥 참가자 추가: {room_id} - {user_id}")
+                return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"❌ 참가자 추가 실패: {room_id} - {user_id} - {e}")
+            return False
+    
+    def set_room_info(self, room_id: str, name: str = None, description: str = None) -> bool:
+        """채팅방 정보 설정"""
+        try:
+            context = self.get_room_context(room_id)
+            
+            if name:
+                context.room_name = name
+            if description:
+                context.description = description
+            
+            context.last_updated = time.time()
+            
+            self._save_context_to_file(context)
+            logger.info(f"🏷️ 채팅방 정보 설정: {room_id} - {name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 채팅방 정보 설정 실패: {room_id} - {e}")
+            return False
+    
+    def get_context_summary(self, room_id: str) -> Dict[str, Any]:
+        """채팅방 컨텍스트 요약 반환"""
+        try:
+            context = self.get_room_context(room_id)
+            
+            return {
+                "room_id": context.room_id,
+                "room_name": context.room_name,
+                "description": context.description,
+                "participants": context.participants,
+                "total_documents": len(context.documents),
+                "total_messages": context.total_messages,
+                "conversation_summary": context.conversation_summary,
+                "key_topics": context.key_topics,
+                "last_updated": context.last_updated,
+                "documents": [
+                    {
+                        "document_id": doc.document_id if hasattr(doc, 'document_id') else doc.get('document_id', 'unknown'),
+                        "filename": doc.filename if hasattr(doc, 'filename') else doc.get('filename', 'unknown'),
+                        "uploaded_at": doc.uploaded_at if hasattr(doc, 'uploaded_at') else doc.get('uploaded_at', 0),
+                        "document_type": doc.document_type if hasattr(doc, 'document_type') else doc.get('document_type', 'unknown'),
+                        "page_count": doc.page_count if hasattr(doc, 'page_count') else doc.get('page_count', 0),
+                        "chunk_count": doc.chunk_count if hasattr(doc, 'chunk_count') else doc.get('chunk_count', 0),
+                        "summary": doc.summary if hasattr(doc, 'summary') else doc.get('summary', '')
+                    }
+                    for doc in context.documents[-5:]  # 최근 5개만
+                ]
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ 컨텍스트 요약 생성 실패: {room_id} - {e}")
+            return {}
+    
+    def _create_new_context(self, room_id: str) -> RoomContext:
+        """새 채팅방 컨텍스트 생성"""
+        context = RoomContext(
+            room_id=room_id,
+            created_at=time.time(),
+            last_updated=time.time()
+        )
+        
+        # 기본 설정
+        context.room_name = f"채팅방 {room_id}"
+        context.description = "새로 생성된 채팅방입니다."
+        
+        # 파일에 저장
+        self._save_context_to_file(context)
+        
+        logger.info(f"🆕 새 채팅방 컨텍스트 생성: {room_id}")
+        return context
+    
+    def _save_context_to_file(self, context: RoomContext) -> bool:
+        """컨텍스트를 파일에 저장"""
+        try:
+            file_path = self.storage_dir / f"{context.room_id}.json"
+            
+            with open(file_path, 'w', encoding='utf-8') as f:
+                json.dump(asdict(context), f, ensure_ascii=False, indent=2)
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 컨텍스트 파일 저장 실패: {context.room_id} - {e}")
+            return False
+    
+    def _load_context_from_file(self, room_id: str) -> Optional[RoomContext]:
+        """파일에서 컨텍스트 로드"""
+        try:
+            file_path = self.storage_dir / f"{room_id}.json"
+            
+            if not file_path.exists():
+                return None
+            
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            # documents 리스트의 각 항목을 RoomDocument 객체로 변환
+            if 'documents' in data and isinstance(data['documents'], list):
+                documents = []
+                for doc_data in data['documents']:
+                    if isinstance(doc_data, dict):
+                        # 딕셔너리를 RoomDocument 객체로 변환
+                        doc = RoomDocument(**doc_data)
+                        documents.append(doc)
+                    else:
+                        # 이미 RoomDocument 객체인 경우
+                        documents.append(doc_data)
+                data['documents'] = documents
+            
+            # RoomContext 객체로 변환
+            context = RoomContext(**data)
+            logger.debug(f"📂 파일에서 컨텍스트 로드: {room_id}")
+            return context
+            
+        except Exception as e:
+            logger.error(f"❌ 컨텍스트 파일 로드 실패: {room_id} - {e}")
+            return None
+    
+    def _add_to_cache(self, room_id: str, context: RoomContext):
+        """캐시에 컨텍스트 추가 (크기 제한 확인)"""
+        if len(self.room_cache) >= self.cache_size_limit:
+            # 가장 오래된 컨텍스트 제거 (LRU 방식)
+            oldest_room = min(self.room_cache.keys(), 
+                             key=lambda k: self.room_cache[k].last_updated)
+            del self.room_cache[oldest_room]
+            logger.debug(f"🗑️ 캐시에서 오래된 컨텍스트 제거: {oldest_room}")
+        
+        self.room_cache[room_id] = context
+    
+    def get_all_rooms(self) -> List[str]:
+        """모든 채팅방 ID 반환"""
+        try:
+            room_files = list(self.storage_dir.glob("*.json"))
+            room_ids = [f.stem for f in room_files]
+            return room_ids
+            
+        except Exception as e:
+            logger.error(f"❌ 채팅방 목록 조회 실패: {e}")
+            return []
+    
+    def delete_room_context(self, room_id: str) -> bool:
+        """채팅방 컨텍스트 삭제"""
+        try:
+            # 캐시에서 제거
+            if room_id in self.room_cache:
+                del self.room_cache[room_id]
+            
+            # 파일 삭제
+            file_path = self.storage_dir / f"{room_id}.json"
+            if file_path.exists():
+                file_path.unlink()
+            
+            logger.info(f"🗑️ 채팅방 컨텍스트 삭제 완료: {room_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 채팅방 컨텍스트 삭제 실패: {room_id} - {e}")
+            return False
+
+# 전역 인스턴스
+room_context_manager = RoomContextManager()

lily_llm_core/user_memory_manager.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""
+사용자별 전역 장기 기억 관리자 (User Memory Manager)
+ChatGPT의 '메모리' 기능과 유사한 사용자별 전역 정보 저장 시스템
+"""
+
+import logging
+import time
+import json
+import os
+from typing import Dict, Any, List, Optional, Tuple
+from dataclasses import dataclass, asdict
+from pathlib import Path
+import hashlib
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class UserMemory:
+    """사용자별 전역 메모리 데이터"""
+    user_id: str
+    created_at: float
+    last_updated: float
+    
+    # 기본 정보
+    name: Optional[str] = None
+    preferences: Dict[str, Any] = None
+    important_info: List[str] = None
+    
+    # 대화 패턴 및 선호도
+    communication_style: Optional[str] = None
+    language_preference: Optional[str] = None
+    response_length_preference: Optional[str] = None
+    
+    # 전문 분야 및 관심사
+    expertise_areas: List[str] = None
+    interests: List[str] = None
+    
+    # 사용 패턴 통계
+    total_conversations: int = 0
+    total_messages: int = 0
+    favorite_topics: List[str] = None
+    
+    # AI 설정 및 선호도
+    ai_personality: Optional[str] = None
+    ai_response_style: Optional[str] = None
+    
+    def __post_init__(self):
+        if self.preferences is None:
+            self.preferences = {}
+        if self.important_info is None:
+            self.important_info = []
+        if self.expertise_areas is None:
+            self.expertise_areas = []
+        if self.interests is None:
+            self.interests = []
+        if self.favorite_topics is None:
+            self.favorite_topics = []
+
+class UserMemoryManager:
+    """사용자별 전역 메모리 관리자"""
+    
+    def __init__(self, storage_dir: str = "user_memories"):
+        self.storage_dir = Path(storage_dir)
+        self.storage_dir.mkdir(exist_ok=True)
+        
+        # 메모리 캐시 (메모리 효율성)
+        self.memory_cache: Dict[str, UserMemory] = {}
+        self.cache_size_limit = 100  # 최대 100명의 메모리를 캐시
+        
+        # 메모리 통계
+        self.total_users = 0
+        self.total_memories = 0
+        
+        logger.info(f"🚀 UserMemoryManager 초기화: {self.storage_dir}")
+    
+    def get_user_memory(self, user_id: str) -> UserMemory:
+        """사용자 메모리 조회 (캐시 우선)"""
+        # 캐시에서 먼저 확인
+        if user_id in self.memory_cache:
+            logger.debug(f"📋 캐시에서 사용자 메모리 조회: {user_id}")
+            return self.memory_cache[user_id]
+        
+        # 파일에서 로드
+        memory = self._load_memory_from_file(user_id)
+        if memory:
+            # 캐시에 추가 (캐시 크기 제한 확인)
+            self._add_to_cache(user_id, memory)
+            return memory
+        
+        # 새 메모리 생성
+        memory = self._create_new_memory(user_id)
+        self._add_to_cache(user_id, memory)
+        return memory
+    
+    def update_user_memory(self, user_id: str, updates: Dict[str, Any]) -> bool:
+        """사용자 메모리 업데이트"""
+        try:
+            memory = self.get_user_memory(user_id)
+            
+            # 업데이트 적용
+            for key, value in updates.items():
+                if hasattr(memory, key):
+                    setattr(memory, key, value)
+                    logger.debug(f"📝 사용자 메모리 업데이트: {user_id}.{key} = {value}")
+            
+            # 타임스탬프 업데이트
+            memory.last_updated = time.time()
+            
+            # 파일에 저장
+            self._save_memory_to_file(memory)
+            
+            # 캐시 업데이트
+            if user_id in self.memory_cache:
+                self.memory_cache[user_id] = memory
+            
+            logger.info(f"✅ 사용자 메모리 업데이트 완료: {user_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 사용자 메모리 업데이트 실패: {user_id} - {e}")
+            return False
+    
+    def add_important_info(self, user_id: str, info: str) -> bool:
+        """중요 정보 추가"""
+        try:
+            memory = self.get_user_memory(user_id)
+            
+            if info not in memory.important_info:
+                memory.important_info.append(info)
+                memory.last_updated = time.time()
+                
+                self._save_memory_to_file(memory)
+                logger.info(f"📌 중요 정보 추가: {user_id} - {info[:50]}...")
+                return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"❌ 중요 정보 추가 실패: {user_id} - {e}")
+            return False
+    
+    def update_preferences(self, user_id: str, preferences: Dict[str, Any]) -> bool:
+        """사용자 선호도 업데이트"""
+        try:
+            memory = self.get_user_memory(user_id)
+            
+            # 기존 선호도와 병합
+            memory.preferences.update(preferences)
+            memory.last_updated = time.time()
+            
+            self._save_memory_to_file(memory)
+            logger.info(f"⚙️ 사용자 선호도 업데이트: {user_id} - {len(preferences)}개 항목")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 사용자 선호도 업데이트 실패: {user_id} - {e}")
+            return False
+    
+    def record_conversation(self, user_id: str, topic: str = None) -> bool:
+        """대화 기록 (통계 업데이트)"""
+        try:
+            memory = self.get_user_memory(user_id)
+            
+            memory.total_conversations += 1
+            memory.total_messages += 1
+            
+            if topic and topic not in memory.favorite_topics:
+                memory.favorite_topics.append(topic)
+                # 최대 10개까지만 유지
+                if len(memory.favorite_topics) > 10:
+                    memory.favorite_topics = memory.favorite_topics[-10:]
+            
+            memory.last_updated = time.time()
+            
+            self._save_memory_to_file(memory)
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 대화 기록 실패: {user_id} - {e}")
+            return False
+    
+    def get_memory_summary(self, user_id: str) -> Dict[str, Any]:
+        """사용자 메모리 요약 반환"""
+        try:
+            memory = self.get_user_memory(user_id)
+            
+            return {
+                "user_id": memory.user_id,
+                "name": memory.name,
+                "preferences": memory.preferences,
+                "important_info": memory.important_info[:5],  # 최근 5개만
+                "expertise_areas": memory.expertise_areas,
+                "interests": memory.interests,
+                "communication_style": memory.communication_style,
+                "ai_personality": memory.ai_personality,
+                "total_conversations": memory.total_conversations,
+                "favorite_topics": memory.favorite_topics[-5:],  # 최근 5개만
+                "last_updated": memory.last_updated
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ 메모리 요약 생성 실패: {user_id} - {e}")
+            return {}
+    
+    def _create_new_memory(self, user_id: str) -> UserMemory:
+        """새 사용자 메모리 생성"""
+        memory = UserMemory(
+            user_id=user_id,
+            created_at=time.time(),
+            last_updated=time.time()
+        )
+        
+        # 기본 설정
+        memory.language_preference = "ko"
+        memory.response_length_preference = "medium"
+        memory.ai_personality = "friendly"
+        memory.ai_response_style = "helpful"
+        
+        # 파일에 저장
+        self._save_memory_to_file(memory)
+        
+        logger.info(f"🆕 새 사용자 메모리 생성: {user_id}")
+        return memory
+    
+    def _save_memory_to_file(self, memory: UserMemory) -> bool:
+        """메모리를 파일에 저장"""
+        try:
+            file_path = self.storage_dir / f"{memory.user_id}.json"
+            
+            with open(file_path, 'w', encoding='utf-8') as f:
+                json.dump(asdict(memory), f, ensure_ascii=False, indent=2)
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 메모리 파일 저장 실패: {memory.user_id} - {e}")
+            return False
+    
+    def _load_memory_from_file(self, user_id: str) -> Optional[UserMemory]:
+        """파일에서 메모리 로드"""
+        try:
+            file_path = self.storage_dir / f"{user_id}.json"
+            
+            if not file_path.exists():
+                return None
+            
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            # UserMemory 객체로 변환
+            memory = UserMemory(**data)
+            logger.debug(f"📂 파일에서 메모리 로드: {user_id}")
+            return memory
+            
+        except Exception as e:
+            logger.error(f"❌ 메모리 파일 로드 실패: {user_id} - {e}")
+            return None
+    
+    def _add_to_cache(self, user_id: str, memory: UserMemory):
+        """캐시에 메모리 추가 (크기 제한 확인)"""
+        if len(self.memory_cache) >= self.cache_size_limit:
+            # 가장 오래된 메모리 제거 (LRU 방식)
+            oldest_user = min(self.memory_cache.keys(), 
+                            key=lambda k: self.memory_cache[k].last_updated)
+            del self.memory_cache[oldest_user]
+            logger.debug(f"🗑️ 캐시에서 오래된 메모리 제거: {oldest_user}")
+        
+        self.memory_cache[user_id] = memory
+    
+    def get_all_users(self) -> List[str]:
+        """모든 사용자 ID 반환"""
+        try:
+            user_files = list(self.storage_dir.glob("*.json"))
+            user_ids = [f.stem for f in user_files]
+            return user_ids
+            
+        except Exception as e:
+            logger.error(f"❌ 사용자 목록 조회 실패: {e}")
+            return []
+    
+    def delete_user_memory(self, user_id: str) -> bool:
+        """사용자 메모리 삭제"""
+        try:
+            # 캐시에서 제거
+            if user_id in self.memory_cache:
+                del self.memory_cache[user_id]
+            
+            # 파일 삭제
+            file_path = self.storage_dir / f"{user_id}.json"
+            if file_path.exists():
+                file_path.unlink()
+            
+            logger.info(f"🗑️ 사용자 메모리 삭제 완료: {user_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 사용자 메모리 삭제 실패: {user_id} - {e}")
+            return False
+
+# 전역 인스턴스
+user_memory_manager = UserMemoryManager()

room_contexts/default.json

@@ -0,0 +1,60 @@
+{
+  "room_id": "default",
+  "created_at": 1755887199.998416,
+  "last_updated": 1755888375.434728,
+  "room_name": "채팅방 default",
+  "description": "새로 생성된 채팅방입니다.",
+  "participants": [
+    "kdy"
+  ],
+  "documents": [
+    {
+      "document_id": "32653a11",
+      "filename": "oop커피매니저.pdf",
+      "uploaded_at": 1755887816.48926,
+      "uploaded_by": "kdy",
+      "document_type": "pdf",
+      "page_count": 0,
+      "chunk_count": 0,
+      "summary": "문서가 성공적으로 처리되었습니다.",
+      "tags": []
+    },
+    {
+      "document_id": "8991b80f",
+      "filename": "test_math.pdf",
+      "uploaded_at": 1755887939.8704937,
+      "uploaded_by": "kdy",
+      "document_type": "pdf",
+      "page_count": 0,
+      "chunk_count": 0,
+      "summary": "문서가 성공적으로 처리되었습니다.",
+      "tags": []
+    },
+    {
+      "document_id": "8ed78561",
+      "filename": "test_design.pdf",
+      "uploaded_at": 1755888122.0620363,
+      "uploaded_by": "kdy",
+      "document_type": "pdf",
+      "page_count": 0,
+      "chunk_count": 0,
+      "summary": "문서가 성공적으로 처리되었습니다.",
+      "tags": []
+    },
+    {
+      "document_id": "c737d6d1",
+      "filename": "test_design.pdf",
+      "uploaded_at": 1755888375.4331617,
+      "uploaded_by": "kdy",
+      "document_type": "pdf",
+      "page_count": 0,
+      "chunk_count": 0,
+      "summary": "문서가 성공적으로 처리되었습니다.",
+      "tags": []
+    }
+  ],
+  "conversation_summary": null,
+  "key_topics": [],
+  "total_messages": 4,
+  "ai_context": {}
+}

user_memories/anonymous.json

@@ -0,0 +1,18 @@
+{
+  "user_id": "anonymous",
+  "created_at": 1755887199.9962583,
+  "last_updated": 1755887199.9962583,
+  "name": null,
+  "preferences": {},
+  "important_info": [],
+  "communication_style": null,
+  "language_preference": "ko",
+  "response_length_preference": "medium",
+  "expertise_areas": [],
+  "interests": [],
+  "total_conversations": 0,
+  "total_messages": 0,
+  "favorite_topics": [],
+  "ai_personality": "friendly",
+  "ai_response_style": "helpful"
+}

user_memories/kdy.json

@@ -0,0 +1,22 @@
+{
+  "user_id": "kdy",
+  "created_at": 1755887816.4909644,
+  "last_updated": 1755888375.434728,
+  "name": null,
+  "preferences": {},
+  "important_info": [],
+  "communication_style": null,
+  "language_preference": "ko",
+  "response_length_preference": "medium",
+  "expertise_areas": [],
+  "interests": [],
+  "total_conversations": 8,
+  "total_messages": 8,
+  "favorite_topics": [
+    "문서 업로드: oop커피매니저.pdf",
+    "문서 업로드: test_math.pdf",
+    "문서 업로드: test_design.pdf"
+  ],
+  "ai_personality": "friendly",
+  "ai_response_style": "helpful"
+}