Auto commit at 23-2025-08 6:54:22

lily_llm_api/app_v2.py

@@ -62,6 +62,7 @@ from lily_llm_core.context_manager import get_context_manager, context_manager
 
 # 계층적 메모리 시스템 추가
 from lily_llm_core.integrated_memory_manager import integrated_memory_manager
+from lily_llm_core.text_summarizer import text_summarizer, SummaryConfig
 
 # 전역 변수들
 current_model = None  # 🔄 현재 로드된 모델 인스턴스
@@ -580,207 +581,69 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
                 
                 # 2. RAG 검색 결과 컨텍스트 (PDF 내용 포함)
                 try:
-                    # 🔄 새로운 메모리 시스템을 사용한 RAG 컨텍스트 로드
+                    # �� 새로운 메모리 시스템을 사용한 RAG 컨텍스트 로드
                     rag_context = ""
                     
-                    # 통합 메모리 관리자에서 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)}")
+                    # 🔒 사용자 설정 확인
+                    from lily_llm_core.user_memory_manager import user_memory_manager
+                    keep_memory = user_memory_manager.get_memory_setting(user_id, "keep_memory_on_room_change")
                     
-                    # 기존 RAG 시스템에서 문서 내용 가져오기 (room_id 기반)
-                    try:
-                        # 채팅방별 문서 컨텍스트 조회
-                        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_path = os.path.join(user_path, latest_doc_id)
-                                    if os.path.exists(doc_path):
-                                        
-                                        # 문서 내용 파일 직접 읽기 (pickle 파일 지원)
-                                        if os.path.exists(doc_path):
-                                            # 🔄 pickle 파일에서 내용 읽기 (우선)
-                                            pickle_file = os.path.join(doc_path, "simple_vector_store.pkl")
-                                            if os.path.exists(pickle_file):
-                                                try:
-                                                    import pickle
-                                                    with open(pickle_file, 'rb') as f:
-                                                        vector_store_data = pickle.load(f)
-                                                    
-                                                    # vector store에서 문서 내용 추출 (dict 구조)
-                                                    if isinstance(vector_store_data, dict) and 'documents' in vector_store_data:
-                                                        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:
-                                                                        # 구조화된 컨텐츠인지 확인
-                                                                        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:
-                                                            print(f"⚠️ [DEBUG] pickle 파일에 문서 데이터 없음")
-                                                    else:
-                                                        print(f"⚠️ [DEBUG] pickle 파일에 documents 키 없음: {list(vector_store_data.keys()) if isinstance(vector_store_data, dict) else 'Not a dict'}")
-                                                except Exception as e:
-                                                    print(f"⚠️ [DEBUG] pickle 파일 읽기 실패: {e}")
-                                                    
-                                                    # 🔄 fallback: documents.json 파일 시도
-                                                    docs_file = os.path.join(doc_path, "documents.json")
-                                                    if os.path.exists(docs_file):
-                                                        try:
-                                                            with open(docs_file, 'r', encoding='utf-8') as f:
-                                                                documents_data = json.load(f)
-                                                            
-                                                            if documents_data and len(documents_data) > 0:
-                                                                rag_context = "\n\n📄 업로드된 문서 내용:\n"
-                                                                for i, doc in enumerate(documents_data[:2]):  # 최대 2개 청크
-                                                                    if 'page_content' in doc:
-                                                                        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 len(rag_context) > 30:
-                                                                    context_prompt += rag_context
-                                                                    print(f"🔍 [DEBUG] RAG 컨텍스트 포함됨 (JSON fallback) - 길이: {len(rag_context)}")
-                                                                    print(f"🔍 [DEBUG] RAG 컨텍스트 미리보기: {rag_context[:100]}...")
-                                                                else:
-                                                                    print(f"⚠️ [DEBUG] RAG 컨텍스트가 너무 짧음: {len(rag_context)}")
-                                                            else:
-                                                                print(f"⚠️ [DEBUG] documents.json 데이터 없음")
-                                                        except Exception as e:
-                                                            print(f"⚠️ [DEBUG] documents.json 읽기 실패: {e}")
-                                                    else:
-                                                        print(f"⚠️ [DEBUG] documents.json 파일 없음: {docs_file}")
-                                            else:
-                                                print(f"⚠️ [DEBUG] pickle 파일 없음: {pickle_file}")
-                                        else:
-                                            print(f"⚠️ [DEBUG] 문서 경로 없음: {doc_path}")
+                    if keep_memory:
+                        # 메모리 유지 모드 - 기존 로직 실행
+                        print(f"🔄 [DEBUG] 사용자 {user_id} 메모리 유지 모드 - 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:
+                            # 채팅방별 문서 컨텍스트 조회
+                            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:
-                                        print(f"⚠️ [DEBUG] 문서 디렉토리 없음: {user_path}")
-                                else:
-                                    print(f"⚠️ [DEBUG] 사용자 경로 없음: {user_path}")
-                            else:
-                                print(f"⚠️ [DEBUG] 사용자 디렉토리 없음: {vector_store_dir}")
-                        else:
-                            print(f"⚠️ [DEBUG] vector_stores 디렉토리 없음")
-                    except Exception as e:
-                        print(f"⚠️ [DEBUG] RAG 컨텍스트 파일 읽기 실패: {e}")
+                                        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}")
+                        
+                        # 🔒 문서 내용 자체는 로드하지 않음 (턴별 초기화)
+                        # 이전 턴에서 첨부된 문서의 실제 내용은 AI 컨텍스트에 포함하지 않음
+                        print(f"�� [DEBUG] 문서 내용 로드 건너뛰기 - 턴별 초기화 적용")
+                        
+                        # �� 현재 턴에서만 문서 정보 표시 (실제 내용은 로드하지 않음)
+                        if rag_context:
+                            context_prompt += rag_context
+                            print(f"🔍 [DEBUG] 문서 목록만 표시 - 실제 내용 로드 안함 (턴별 초기화)")
                     
                 except Exception as e:
                     print(f"⚠️ [DEBUG] RAG 컨텍스트 처리 실패: {e}")
                 
                 if not context_prompt:
-                    print(f"🔍 [DEBUG] 컨텍스트 없음 또는 비어있음 (세션: {session_id})")
+                    print(f"�� [DEBUG] 컨텍스트 없음 또는 비어있음 (세션: {session_id})")
                     
             except Exception as e:
                 print(f"⚠️ [DEBUG] 컨텍스트 로드 실패: {e} (세션: {session_id})")
@@ -1822,6 +1685,7 @@ async def upload_document(
 ):
     """문서 업로드 및 RAG 처리"""
     start_time = time.time()
+    # document_id = None
     
     try:
         # 문서 ID 생성 (제공되지 않은 경우)
@@ -1909,6 +1773,162 @@ async def upload_document(
             error=str(e)
         )
 
+@app.post("/summarize/conversation")
+async def summarize_conversation(
+    room_id: str = Form("default"),
+    user_id: str = Form("anonymous"),
+    max_length: int = Form(300)
+):
+    """🔄 summarizers를 활용한 대화 요약 생성"""
+    try:
+        if not text_summarizer.is_available():
+            return {
+                "success": False,
+                "message": "summarizers 라이브러리를 사용할 수 없습니다."
+            }
+        
+        # 스마트 대화 요약 생성
+        success = integrated_memory_manager.create_smart_conversation_summary(
+            room_id, max_length
+        )
+        
+        if success:
+            # 업데이트된 컨텍스트 조회
+            room_context = integrated_memory_manager.room_context_manager.get_room_context(room_id)
+            
+            return {
+                "success": True,
+                "message": "대화 요약 생성 완료",
+                "summary": room_context.conversation_summary if room_context else "",
+                "key_topics": room_context.key_topics if room_context else [],
+                "room_id": room_id
+            }
+        else:
+            return {
+                "success": False,
+                "message": "대화 요약 생성 실패"
+            }
+            
+    except Exception as e:
+        logger.error(f"❌ 대화 요약 생성 실패: {e}")
+        return {
+            "success": False,
+            "message": f"대화 요약 생성 중 오류 발생: {str(e)}"
+        }
+
+@app.post("/summarize/text")
+async def summarize_text(
+    text: str = Form(...),
+    max_length: int = Form(200),
+    model_name: str = Form("kobart")
+):
+    """🔄 summarizers를 활용한 텍스트 요약"""
+    try:
+        if not text_summarizer.is_available():
+            return {
+                "success": False,
+                "message": "summarizers 라이브러리를 사용할 수 없습니다."
+            }
+        
+        if not text or len(text.strip()) < 50:
+            return {
+                "success": False,
+                "message": "요약할 텍스트가 너무 짧습니다 (최소 50자 필요)"
+            }
+        
+        # 요약 설정
+        config = SummaryConfig(
+            max_length=max_length,
+            min_length=max_length // 2,
+            do_sample=False,
+            temperature=0.7,
+            top_p=0.9
+        )
+        
+        # 요약 수행
+        summary = text_summarizer.summarize_text(text, model_name, config)
+        
+        if summary:
+            compression_ratio = len(summary) / len(text)
+            return {
+                "success": True,
+                "message": "텍스트 요약 완료",
+                "original_length": len(text),
+                "summary_length": len(summary),
+                "compression_ratio": round(compression_ratio, 2),
+                "summary": summary,
+                "model_used": model_name
+            }
+        else:
+            return {
+                "success": False,
+                "message": "요약 생성 실패"
+            }
+            
+    except Exception as e:
+        logger.error(f"❌ 텍스트 요약 실패: {e}")
+        return {
+            "success": False,
+            "message": f"텍스트 요약 중 오류 발생: {str(e)}"
+        }
+
+@app.post("/compress/context")
+async def compress_context(
+    room_id: str = Form("default"),
+    target_length: int = Form(800)
+):
+    """🔄 채팅방 컨텍스트 압축"""
+    try:
+        if not text_summarizer.is_available():
+            return {
+                "success": False,
+                "message": "summarizers 라이브러리를 사용할 수 없습니다."
+            }
+        
+        # 컨텍스트 압축 수행
+        success = integrated_memory_manager.compress_room_context(room_id, target_length)
+        
+        if success:
+            return {
+                "success": True,
+                "message": "컨텍스트 압축 완료",
+                "room_id": room_id,
+                "target_length": target_length
+            }
+        else:
+            return {
+                "success": False,
+                "message": "컨텍스트 압축 실패"
+            }
+            
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 압축 실패: {e}")
+        return {
+            "success": False,
+            "message": f"컨텍스트 압축 중 오류 발생: {str(e)}"
+        }
+
+@app.get("/summarizer/status")
+async def get_summarizer_status():
+    """🔄 summarizers 라이브러리 상태 확인"""
+    try:
+        available = text_summarizer.is_available()
+        models = text_summarizer.get_available_models() if available else []
+        
+        return {
+            "success": True,
+            "summarizers_available": available,
+            "available_models": models,
+            "default_model": "hyunwoongko/kobart" if available else None
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ summarizer 상태 확인 실패: {e}")
+        return {
+            "success": False,
+            "message": f"상태 확인 중 오류 발생: {str(e)}"
+        }        
+
 @app.post("/rag/generate", response_model=RAGResponse)
 async def generate_rag_response(
     query: str = Form(...),
@@ -4330,3 +4350,119 @@ async def advanced_context_health_check():
         }
     except Exception as e:
         return {"status": "error", "message": str(e)}
+"" 
+
+# ============================================================================
+# 사용자 메모리 설정 관리 API
+# ============================================================================
+
+@app.get("/user/memory/settings/{user_id}")
+async def get_user_memory_settings(user_id: str):
+    """사용자 메모리 설정 조회"""
+    try:
+        from lily_llm_core.user_memory_manager import user_memory_manager
+        
+        # 기본 설정 조회
+        keep_memory = user_memory_manager.get_memory_setting(user_id, "keep_memory_on_room_change")
+        
+        return {
+            "status": "success",
+            "user_id": user_id,
+            "settings": {
+                "keep_memory_on_room_change": keep_memory if keep_memory is not None else True
+            }
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@app.post("/user/memory/settings/{user_id}")
+async def update_user_memory_settings(
+    user_id: str,
+    keep_memory_on_room_change: bool = Form(True)
+):
+    """사용자 메모리 설정 업데이트"""
+    try:
+        from lily_llm_core.user_memory_manager import user_memory_manager
+        
+        # 설정 업데이트
+        success = user_memory_manager.update_memory_setting(
+            user_id, "keep_memory_on_room_change", keep_memory_on_room_change
+        )
+        
+        if success:
+            return {
+                "status": "success",
+                "message": f"사용자 {user_id} 메모리 설정 업데이트 완료",
+                "settings": {
+                    "keep_memory_on_room_change": keep_memory_on_room_change
+                }
+            }
+        else:
+            return {"status": "error", "message": "설정 업데이트 실패"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@app.post("/user/memory/room-change/{user_id}")
+async def handle_room_change(user_id: str, new_room_id: str = Form(...)):
+    """Room 변경 시 메모리 처리"""
+    try:
+        from lily_llm_core.user_memory_manager import user_memory_manager
+        from lily_llm_core.integrated_memory_manager import integrated_memory_manager
+        
+        # 사용자 설정 확인
+        keep_memory = user_memory_manager.get_memory_setting(user_id, "keep_memory_on_room_change")
+        
+        if keep_memory:
+            # 메모리 유지 (기본 동작)
+            logger.info(f"🔄 사용자 {user_id}가 room {new_room_id}로 이동 - 메모리 유지")
+            return {
+                "status": "success",
+                "message": f"Room {new_room_id}로 이동 - 메모리 유지됨",
+                "memory_preserved": True
+            }
+        else:
+            # 메모리 초기화
+            logger.info(f"🔄 사용자 {user_id}가 room {new_room_id}로 이동 - 메모리 초기화")
+            
+            # 세션 컨텍스트 초기화
+            if context_manager:
+                # 사용자 관련 세션들 찾아서 초기화
+                user_sessions = [
+                    session_id for session_id in context_manager.session_conversations.keys()
+                    if f"user_{user_id}" in session_id
+                ]
+                
+                for session_id in user_sessions:
+                    context_manager.clear_session_context(session_id)
+                    logger.info(f"🗑️ 세션 컨텍스트 초기화: {session_id}")
+            
+            # Room 컨텍스트 초기화 (사용자 관련 문서 제거)
+            try:
+                room_context = integrated_memory_manager.room_context_manager.get_room_context(new_room_id)
+                if room_context and room_context.documents:
+                    # 사용자가 업로드한 문서들 제거
+                    original_count = len(room_context.documents)
+                    room_context.documents = [
+                        doc for doc in room_context.documents
+                        if (isinstance(doc, dict) and doc.get('uploaded_by') != user_id) or
+                           (hasattr(doc, 'uploaded_by') and getattr(doc, 'uploaded_by') != user_id)
+                    ]
+                    
+                    # 변경사항 저장
+                    integrated_memory_manager.room_context_manager.save_room_context(new_room_id, room_context)
+                    
+                    removed_count = original_count - len(room_context.documents)
+                    logger.info(f"��️ Room {new_room_id}에서 사용자 {user_id} 문서 {removed_count}개 제거")
+            except Exception as e:
+                logger.warning(f"⚠️ Room 컨텍스트 초기화 실패: {e}")
+            
+            return {
+                "status": "success",
+                "message": f"Room {new_room_id}로 이동 - 메모리 초기화됨",
+                "memory_preserved": False,
+                "context_cleared": True
+            }
+            
+    except Exception as e:
+        logger.error(f"❌ Room 변경 처리 실패: {e}")
+        return {"status": "error", "message": str(e)}

lily_llm_core/context_manager.py

@@ -12,6 +12,8 @@ from collections import deque
 import json
 import re
 
+from .text_summarizer import text_summarizer, SummaryConfig
+
 logger = logging.getLogger(__name__)
 
 @dataclass
@@ -911,10 +913,37 @@ class AdvancedContextManager:
         return summary
     
     def _smart_summarize(self, content: str, role: str) -> str:
-        """스마트 요약 - 문장 단위로 요약"""
+        """스마트 요약 - summarizers 라이브러리 기반 고품질 요약"""
         if len(content) <= 150:
             return content
         
+        # 🔄 summarizers 라이브러리 기반 요약 시도
+        if text_summarizer.is_available():
+            try:
+                # 요약 설정
+                config = SummaryConfig(
+                    max_length=200,  # 요약 길이 제한
+                    min_length=50,
+                    do_sample=False,  # 일관성 유지
+                    temperature=0.7,  # 적당한 창의성
+                    top_p=0.9
+                )
+                
+                # summarizers를 사용한 요약
+                summary = text_summarizer.summarize_text(content, config=config)
+                
+                if summary and len(summary.strip()) > 0:
+                    logger.debug(f"✅ summarizers 기반 스마트 요약 완료: {len(content)} → {len(summary)} 문자")
+                    return summary.strip()
+                else:
+                    logger.debug("summarizers 요약 실패, 기본 요약 사용")
+                    
+            except Exception as e:
+                logger.debug(f"summarizers 요약 실패: {e}, 기본 요약 사용")
+        else:
+            logger.debug("summarizers 라이브러리를 사용할 수 없습니다. 기본 요약 사용")
+        
+        # 🔄 기본 요약 (summarizers 실패 시)
         # 문장 단위로 분리
         sentences = re.split(r'[.!?]+', content)
         sentences = [s.strip() for s in sentences if s.strip()]

lily_llm_core/integrated_memory_manager.py

@@ -12,6 +12,7 @@ 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
+from .text_summarizer import text_summarizer, SummaryConfig
 
 logger = logging.getLogger(__name__)
 
@@ -156,6 +157,148 @@ class IntegratedMemoryManager:
             logger.error(f"❌ 대화 기록 실패: {user_id}/{room_id} - {e}")
             return False
     
+    def update_conversation_summary(self, room_id: str, summary: str, topics: List[str] = None) -> bool:
+        """대화 요약 업데이트"""
+        try:
+            success = self.room_context_manager.update_conversation_summary(room_id, summary, topics)
+            
+            if success:
+                logger.info(f"✅ 대화 요약 업데이트: {room_id} - {len(summary)} 문자")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"❌ 대화 요약 업데이트 실패: {room_id} - {e}")
+            return False
+    
+    def create_smart_conversation_summary(self, room_id: str, max_length: int = 300) -> bool:
+        """🔄 summarizers를 활용한 스마트 대화 요약 생성"""
+        try:
+            if not text_summarizer.is_available():
+                logger.warning("summarizers 라이브러리를 사용할 수 없습니다.")
+                return False
+            
+            # 채팅방 컨텍스트 조회
+            room_context = self.room_context_manager.get_room_context(room_id)
+            if not room_context:
+                logger.warning(f"채팅방 컨텍스트를 찾을 수 없습니다: {room_id}")
+                return False
+            
+            # 대화 내용 수집 (최근 메시지들)
+            conversation_text = ""
+            if hasattr(room_context, 'conversation_summary') and room_context.conversation_summary:
+                conversation_text += f"이전 요약: {room_context.conversation_summary}\n"
+            
+            # 참가자 정보
+            if hasattr(room_context, 'participants') and room_context.participants:
+                conversation_text += f"참가자: {', '.join(room_context.participants)}\n"
+            
+            # 문서 정보
+            if hasattr(room_context, 'documents') and room_context.documents:
+                doc_names = []
+                for doc in room_context.documents[-3:]:
+                    if isinstance(doc, dict):
+                        filename = doc.get('filename', 'unknown')
+                    else:
+                        filename = getattr(doc, 'filename', 'unknown')
+                    doc_names.append(filename)
+                
+                conversation_text += f"업로드된 문서: {', '.join(doc_names)}\n"
+            
+            if len(conversation_text.strip()) < 50:
+                logger.debug("요약할 내용이 충분하지 않습니다.")
+                return False
+            
+            # 요약 설정
+            config = SummaryConfig(
+                max_length=max_length,
+                min_length=100,
+                do_sample=False,
+                temperature=0.7,
+                top_p=0.9
+            )
+            
+            # summarizers를 사용한 요약
+            summary = text_summarizer.summarize_text(conversation_text, config=config)
+            
+            if summary and len(summary.strip()) > 0:
+                # 핵심 주제 추출
+                key_topics = text_summarizer.extract_key_points(conversation_text, max_points=3)
+                
+                # 요약 업데이트
+                success = self.room_context_manager.update_conversation_summary(
+                    room_id, summary.strip(), key_topics
+                )
+                
+                if success:
+                    logger.info(f"✅ 스마트 대화 요약 생성 완료: {room_id} - {len(summary)} 문자")
+                    return True
+                else:
+                    logger.error("대화 요약 업데이트 실패")
+                    return False
+            else:
+                logger.warning("요약 생성 실패")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ 스마트 대화 요약 생성 실패: {room_id} - {e}")
+            return False
+    
+    def compress_room_context(self, room_id: str, target_length: int = 800) -> bool:
+        """🔄 채팅방 컨텍스트 압축 (메모리 최적화)"""
+        try:
+            if not text_summarizer.is_available():
+                logger.warning("summarizers 라이브러리를 사용할 수 없습니다.")
+                return False
+            
+            # 채팅방 컨텍스트 조회
+            room_context = self.room_context_manager.get_room_context(room_id)
+            if not room_context:
+                logger.warning(f"채팅방 컨텍스트를 찾을 수 없습니다: {room_id}")
+                return False
+            
+            # 현재 컨텍스트 정보 수집
+            context_parts = []
+            
+            if hasattr(room_context, 'room_name') and room_context.room_name:
+                context_parts.append(f"채팅방: {room_context.room_name}")
+            
+            if hasattr(room_context, 'description') and room_context.description:
+                context_parts.append(f"설명: {room_context.description}")
+            
+            if hasattr(room_context, 'conversation_summary') and room_context.conversation_summary:
+                context_parts.append(f"대화 요약: {room_context.conversation_summary}")
+            
+            if hasattr(room_context, 'key_topics') and room_context.key_topics:
+                context_parts.append(f"주요 주제: {', '.join(room_context.key_topics)}")
+            
+            if not context_parts:
+                logger.debug("압축할 컨텍스트가 없습니다.")
+                return False
+            
+            # 컨텍스트를 하나의 텍스트로 결합
+            full_context = "\n".join(context_parts)
+            
+            if len(full_context) <= target_length:
+                logger.debug("컨텍스트가 이미 충분히 짧습니다.")
+                return False
+            
+            # 압축 수행
+            compressed = text_summarizer.compress_document_content(full_context, target_length)
+            
+            if compressed and len(compressed) <= target_length:
+                # 압축된 컨텍스트로 업데이트
+                # (실제로는 별도 필드에 저장하거나 압축 히스토리 관리)
+                logger.info(f"✅ 채팅방 컨텍스트 압축 완료: {room_id} - {len(full_context)} → {len(compressed)} 문자")
+                return True
+            else:
+                logger.warning("컨텍스트 압축 실패")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ 채팅방 컨텍스트 압축 실패: {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,

lily_llm_core/text_summarizer.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""
+텍스트 요약 및 압축 모듈
+summarizers 라이브러리를 활용하여 컨텍스트 메모리와 문서 내용을 효율적으로 압축
+"""
+
+import logging
+import time
+from typing import Dict, Any, List, Optional, Union
+from dataclasses import dataclass
+
+# 🔄 summarizers 라이브러리 import 시도
+SUMMARIZERS_AVAILABLE = False
+Summarizers = None
+
+try:
+    print("🔍 summarizers 라이브러리 import 시도 중...")
+    from summarizers import Summarizers
+    SUMMARIZERS_AVAILABLE = True
+    print("✅ summarizers 라이브러리 import 성공!")
+except ImportError as e:
+    print(f"❌ summarizers import 실패: {e}")
+    SUMMARIZERS_AVAILABLE = False
+except Exception as e:
+    print(f"⚠️ summarizers import 중 예상치 못한 오류: {e}")
+    SUMMARIZERS_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class SummaryConfig:
+    """요약 설정"""
+    max_length: int = 150  # 최대 요약 길이
+    min_length: int = 30   # 최소 요약 길이
+    do_sample: bool = False  # 샘플링 사용 여부
+    temperature: float = 1.0  # 온도 (높을수록 다양성 증가)
+    top_p: float = 0.9       # top-p 샘플링
+    repetition_penalty: float = 1.0  # 반복 패널티
+
+class TextSummarizer:
+    """텍스트 요약 및 압축 관리자"""
+    
+    def __init__(self):
+        self.summarizers: Dict[str, Any] = {}
+        self.default_model = "hyunwoongko/kobart"  # 기본 한국어 모델
+        
+        print(f"🔍 TextSummarizer 초기화 - SUMMARIZERS_AVAILABLE: {SUMMARIZERS_AVAILABLE}")
+        
+        # 🔒 AI 모델 로딩 비활성화 (PyTorch 버전 문제로 인해)
+        # if SUMMARIZERS_AVAILABLE and Summarizers is not None:
+        #     self._initialize_summarizers()
+        # else:
+        #     logger.warning("summarizers 라이브러리를 사용할 수 없습니다.")
+        #     print("⚠️ summarizers 라이브러리를 사용할 수 없습니다.")
+        
+        print("🔄 간단한 규칙 기반 요약만 사용 (AI 모델 로딩 비활성화)")
+        logger.info("간단한 규칙 기반 요약만 사용 (AI 모델 로딩 비활성화)")
+    
+    def _initialize_summarizers(self):
+        """요약 모델 초기화"""
+        try:
+            print("🔍 요약 모델 초기화 시작...")
+            
+            # 기본 한국어 모델 (normal 타입 사용)
+            print(f"🔍 KoBART 모델 로딩 시도: normal 타입")
+            self.summarizers["kobart"] = Summarizers(type="normal", device="cpu")
+            logger.info(f"✅ KoBART 요약 모델 초기화 완료: normal 타입")
+            print(f"✅ KoBART 요약 모델 초기화 완료: normal 타입")
+            
+            # 추가 모델들 (필요시)
+            # self.summarizers["paper"] = Summarizers(type="paper", device="cpu")
+            # self.summarizers["patent"] = Summarizers(type="patent", device="cpu")
+            
+        except Exception as e:
+            logger.error(f"❌ 요약 모델 초기화 실패: {e}")
+            print(f"❌ 요약 모델 초기화 실패: {e}")
+            print("⚠️ PyTorch 버전 문제로 인해 간단한 요약 방법을 사용합니다.")
+            SUMMARIZERS_AVAILABLE = False
+    
+    def _simple_summarize(self, text: str, max_length: int = 200) -> str:
+        """간단한 규칙 기반 요약 (AI 모델 실패 시 사용)"""
+        if len(text) <= max_length:
+            return text
+        
+        # 문장 단위로 분리
+        sentences = text.split('.')
+        sentences = [s.strip() for s in sentences if s.strip()]
+        
+        if len(sentences) <= 2:
+            return text[:max_length] + "..." if len(text) > max_length else text
+        
+        # 첫 번째와 마지막 문장 + 중간 요약
+        first_sentence = sentences[0]
+        last_sentence = sentences[-1] if sentences[-1] != first_sentence else ""
+        
+        middle_summary = ""
+        if len(sentences) > 2:
+            middle_count = len(sentences) - 2
+            middle_summary = f"[중간 {middle_count}개 문장 요약]"
+        
+        summary_parts = [first_sentence]
+        if middle_summary:
+            summary_parts.append(middle_summary)
+        if last_sentence and last_sentence != first_sentence:
+            summary_parts.append(last_sentence)
+        
+        summary = ". ".join(summary_parts)
+        return summary[:max_length] + "..." if len(summary) > max_length else summary
+    
+    def summarize_text(self, text: str, model_name: str = "kobart", 
+                      config: Optional[SummaryConfig] = None) -> Optional[str]:
+        """텍스트 요약 수행"""
+        if not text or len(text.strip()) < 50:
+            logger.debug("텍스트가 너무 짧아 요약을 건너뜁니다.")
+            return text
+        
+        # 설정 적용
+        if config is None:
+            config = SummaryConfig()
+        
+        # 🔒 AI 모델 기반 요약 비활성화 (PyTorch 버전 문제로 인해)
+        # AI 모델 기반 요약 시도
+        # if SUMMARIZERS_AVAILABLE and model_name in self.summarizers:
+        #     try:
+        #         summarizer = self.summarizers[model_name]
+        #         
+        #         # 요약 수행 (Summarizers의 __call__ 메서드 사용)
+        #         start_time = time.time()
+        #         summary = summarizer(
+        #             contents=text,
+        #             num_beams=5,
+        #             top_k=config.top_p * 100 if config.top_p else None,
+        #             top_p=config.top_p,
+        #             no_repeat_ngram_size=4,
+        #             length_penalty=1.0,
+        #             question_detection=False
+        #         )
+        #         
+        #         processing_time = time.time() - start_time
+        #         
+        #         # 요약 결과 검증
+        #         if summary and len(summary.strip()) > 0:
+        #             compression_ratio = len(summary) / len(summary)
+        #             logger.info(f"✅ AI 모델 요약 완료: {len(text)} → {len(summary)} 문자 "
+        #                       f"(압축률: {compression_ratio:.2f}, 소요시간: {processing_time:.2f}초)")
+        #             return summary.strip()
+        #         else:
+        #             logger.warning("AI 모델 요약 결과가 비어있습니다.")
+        #             
+        #     except Exception as e:
+        #         logger.warning(f"AI 모델 요약 실패: {e}, 간단한 요약 방법 사용")
+        
+        # 간단한 요약 방법 사용 (AI 모델 비활성화)
+        logger.info("🔄 간단한 규칙 기반 요약 사용 (AI 모델 비활성화)")
+        return self._simple_summarize(text, config.max_length)
+    
+    def summarize_conversation(self, conversation_turns: List[Dict[str, Any]], 
+                             max_summary_length: int = 200) -> str:
+        """대화 내용 요약"""
+        if not conversation_turns:
+            return ""
+        
+        try:
+            # 대화 내용을 하나의 텍스트로 결합
+            conversation_text = ""
+            for turn in conversation_turns[-10:]:  # 최근 10턴만
+                if "user" in turn:
+                    conversation_text += f"사용자: {turn['user']}\n"
+                if "assistant" in turn:
+                    conversation_text += f"AI: {turn['assistant']}\n"
+            
+            if len(conversation_text.strip()) < 100:
+                return conversation_text.strip()
+            
+            # 요약 설정
+            config = SummaryConfig(
+                max_length=max_summary_length,
+                min_length=50,
+                do_sample=False,
+                temperature=0.7
+            )
+            
+            # 요약 수행
+            summary = self.summarize_text(conversation_text, config=config)
+            return summary if summary else conversation_text[:max_summary_length] + "..."
+            
+        except Exception as e:
+            logger.error(f"❌ 대화 요약 실패: {e}")
+            return conversation_text[:max_summary_length] + "..." if conversation_text else ""
+    
+    def compress_document_content(self, content: str, target_length: int = 1000) -> str:
+        """문서 내용 압축 (RAG 컨텍스트용)"""
+        if not content or len(content) <= target_length:
+            return content
+        
+        try:
+            # 압축률 계산
+            compression_ratio = target_length / len(content)
+            
+            # 요약 설정 (압축에 최적화)
+            config = SummaryConfig(
+                max_length=target_length,
+                min_length=target_length // 2,
+                do_sample=False,
+                temperature=0.5,  # 일관성 유지
+                top_p=0.8
+            )
+            
+            # 요약 수행
+            compressed = self.summarize_text(content, config=config)
+            
+            if compressed and len(compressed) <= target_length:
+                logger.info(f"✅ 문서 압축 완료: {len(content)} → {len(compressed)} 문자 "
+                          f"(목표: {target_length}, 압축률: {compression_ratio:.2f})")
+                return compressed
+            else:
+                # 요약이 실패하거나 너무 길면 단순 자르기
+                logger.warning("요약 압축 실패, 단순 자르기 사용")
+                return content[:target_length] + "..."
+                
+        except Exception as e:
+            logger.error(f"❌ 문서 압축 실패: {e}")
+            return content[:target_length] + "..."
+    
+    def extract_key_points(self, text: str, max_points: int = 5) -> List[str]:
+        """핵심 포인트 추출"""
+        if not text or len(text.strip()) < 100:
+            return []
+        
+        try:
+            # 짧은 요약으로 핵심 포인트 생성
+            config = SummaryConfig(
+                max_length=100,
+                min_length=30,
+                do_sample=True,
+                temperature=0.8
+            )
+            
+            summary = self.summarize_text(text, config=config)
+            if not summary:
+                return []
+            
+            # 요약문을 문장 단위로 분리하여 핵심 포인트로 사용
+            points = [s.strip() for s in summary.split('.') if s.strip()]
+            return points[:max_points]
+            
+        except Exception as e:
+            logger.error(f"❌ 핵심 포인트 추출 실패: {e}")
+            return []
+    
+    def get_available_models(self) -> List[str]:
+        """사용 가능한 모델 목록 반환"""
+        return list(self.summarizers.keys())
+    
+    def is_available(self) -> bool:
+        """요약 기능 사용 가능 여부"""
+        # 🔒 AI 모델 비활성화로 인해 간단한 요약만 사용 가능
+        available = True  # 간단한 요약은 항상 사용 가능
+        print(f"🔍 TextSummarizer.is_available() 호출 - 결과: {available} (간단한 요약만)")
+        return available
+
+# 전역 인스턴스
+print("🔍 TextSummarizer 전역 인스턴스 생성 중...")
+text_summarizer = TextSummarizer()
+print(f"🔍 TextSummarizer 생성 완료 - 사용 가능: {text_summarizer.is_available()}")

lily_llm_core/user_memory_manager.py

@@ -45,6 +45,9 @@ class UserMemory:
     ai_personality: Optional[str] = None
     ai_response_style: Optional[str] = None
     
+    # Room 이동 시 메모리 유지 설정
+    keep_memory_on_room_change: bool = True  # 기본값: True (메모리 유지)
+    
     def __post_init__(self):
         if self.preferences is None:
             self.preferences = {}
@@ -279,6 +282,47 @@ class UserMemoryManager:
             logger.error(f"❌ 사용자 목록 조회 실패: {e}")
             return []
     
+    def update_memory_setting(self, user_id: str, setting_name: str, value: Any) -> bool:
+        """사용자 메모리 설정 업데이트"""
+        try:
+            memory = self.get_user_memory(user_id)
+            
+            if hasattr(memory, setting_name):
+                setattr(memory, setting_name, 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} - {setting_name} = {value}")
+                return True
+            else:
+                logger.warning(f"⚠️ 존재하지 않는 설정: {setting_name}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ 메모리 설정 업데이트 실패: {user_id} - {setting_name} - {e}")
+            return False
+    
+    def get_memory_setting(self, user_id: str, setting_name: str) -> Any:
+        """사용자 메모리 설정 조회"""
+        try:
+            memory = self.get_user_memory(user_id)
+            
+            if hasattr(memory, setting_name):
+                return getattr(memory, setting_name)
+            else:
+                logger.warning(f"⚠️ 존재하지 않는 설정: {setting_name}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"❌ 메모리 설정 조회 실패: {user_id} - {setting_name} - {e}")
+            return None
+    
     def delete_user_memory(self, user_id: str) -> bool:
         """사용자 메모리 삭제"""
         try:

requirements.txt

@@ -52,4 +52,7 @@ psutil
 python-json-logger
 PyJWT
 einops
-timm
+timm
+
+# summarizers
+summarizers

requirements_full_lily_250823_0436_summarizers.txt

@@ -0,0 +1,152 @@
+accelerate==1.10.0
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+amqp==5.3.1
+annotated-types==0.7.0
+anyio==4.10.0
+attrs==25.3.0
+backoff==2.2.1
+bcrypt==4.3.0
+beautifulsoup4==4.13.4
+billiard==4.2.1
+bitsandbytes==0.47.0
+celery==5.5.3
+certifi==2025.8.3
+cffi==1.17.1
+charset-normalizer==3.4.3
+click==8.2.1
+click-didyoumean==0.3.1
+click-plugins==1.1.1.2
+click-repl==0.3.0
+colorama==0.4.6
+cryptography==45.0.6
+dataclasses-json==0.6.7
+easyocr==1.7.2
+ecdsa==0.19.1
+einops==0.8.1
+emoji==2.14.1
+faiss-cpu==1.12.0
+fastapi==0.116.1
+filelock==3.19.1
+filetype==1.2.0
+frozenlist==1.7.0
+fsspec==2025.7.0
+greenlet==3.2.4
+h11==0.16.0
+html5lib==1.1
+httpcore==1.0.9
+httptools==0.6.4
+httpx==0.28.1
+httpx-sse==0.4.1
+huggingface-hub==0.34.4
+idna==3.10
+imageio==2.37.0
+intel-openmp==2021.4.0
+Jinja2==3.1.6
+joblib==1.5.1
+jsonpatch==1.33
+jsonpointer==3.0.0
+kombu==5.5.4
+langchain==0.3.27
+langchain-community==0.3.27
+langchain-core==0.3.74
+langchain-text-splitters==0.3.9
+langdetect==1.0.9
+langsmith==0.4.14
+lazy_loader==0.4
+lxml==6.0.0
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+marshmallow==3.26.1
+mdurl==0.1.2
+mkl==2021.4.0
+mpmath==1.3.0
+multidict==6.6.4
+mypy_extensions==1.1.0
+networkx==3.5
+ninja==1.13.0
+nltk==3.9.1
+numpy==1.26.4
+olefile==0.47
+opencv-python-headless==4.11.0.86
+orjson==3.11.2
+packaging==25.0
+pandas==2.3.1
+passlib==1.7.4
+peft==0.15.0
+pillow==11.3.0
+prompt_toolkit==3.0.51
+propcache==0.3.2
+psutil==7.0.0
+pyasn1==0.6.1
+pyclipper==1.3.0.post6
+pycparser==2.22
+pydantic==2.11.7
+pydantic-settings==2.10.1
+pydantic_core==2.33.2
+PyJWT==2.10.1
+PyMuPDF==1.26.3
+pypdf==6.0.0
+pytesseract==0.3.13
+python-bidi==0.6.6
+python-dateutil==2.9.0.post0
+python-docx==1.2.0
+python-dotenv==1.1.1
+python-iso639==2025.2.18
+python-jose==3.5.0
+python-json-logger==3.3.0
+python-magic==0.4.27
+python-multipart==0.0.20
+python-oxmsg==0.0.2
+python-pptx==1.0.2
+pytz==2025.2
+PyYAML==6.0.2
+RapidFuzz==3.13.0
+redis==6.4.0
+regex==2025.7.34
+requests==2.32.5
+requests-toolbelt==1.0.0
+rsa==4.9.1
+safetensors==0.6.2
+scikit-image==0.25.2
+scikit-learn==1.7.1
+scipy==1.16.1
+sentence-transformers==2.2.2
+sentencepiece==0.2.1
+shapely==2.1.1
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.7
+SQLAlchemy==2.0.43
+starlette==0.47.2
+summarizers==1.0.4
+sympy==1.14.0
+tbb==2021.13.1
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tifffile==2025.6.11
+timm==1.0.19
+tokenizers==0.21.4
+torch==2.3.1
+torchvision==0.18.1
+tqdm==4.67.1
+transformers==4.55.2
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+tzdata==2025.2
+unstructured==0.18.13
+unstructured-client==0.42.3
+urllib3==2.5.0
+uvicorn==0.35.0
+vine==5.1.0
+watchfiles==1.1.0
+wcwidth==0.2.13
+webencodings==0.5.1
+websockets==15.0.1
+wrapt==1.17.3
+xlsxwriter==3.2.5
+yarl==1.20.1
+zstandard==0.24.0

test_summarizers.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+summarizers 라이브러리 테스트 스크립트
+"""
+
+import sys
+import os
+
+# 프로젝트 루트를 Python 경로에 추가
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from lily_llm_core.text_summarizer import text_summarizer, SummaryConfig
+
+def test_summarizers():
+    """summarizers 라이브러리 기본 기능 테스트"""
+    print("🚀 summarizers 라이브러리 테스트 시작")
+    print("=" * 50)
+    
+    # 1. 라이브러리 상태 확인
+    print("1. 라이브러리 상태 확인:")
+    available = text_summarizer.is_available()
+    print(f"   - summarizers 사용 가능: {available}")
+    
+    if available:
+        models = text_summarizer.get_available_models()
+        print(f"   - 사용 가능한 모델: {models}")
+        print(f"   - 기본 모델: hyunwoongko/kobart")
+    else:
+        print("   ❌ summarizers 라이브러리를 사용할 수 없습니다.")
+        return
+    
+    print()
+    
+    # 2. 간단한 텍스트 요약 테스트
+    print("2. 간단한 텍스트 요약 테스트:")
+    test_text = """
+    인공지능(AI)은 컴퓨터 시스템이 인간의 학습능력과 추론능력, 지각능력을 인공적으로 구현한 기술입니다. 
+    머신러닝과 딥러닝을 포함하여 다양한 분야에서 활용되고 있으며, 
+    자연어 처리, 컴퓨터 비전, 음성 인식 등에서 혁신적인 성과를 보여주고 있습니다. 
+    특히 최근에는 대형 언어 모델(LLM)의 발전으로 AI의 활용 범위가 크게 확장되었습니다.
+    """
+    
+    print(f"   원본 텍스트 길이: {len(test_text.strip())} 문자")
+    
+    # 기본 요약
+    config = SummaryConfig(max_length=100, min_length=50)
+    summary = text_summarizer.summarize_text(test_text, config=config)
+    
+    if summary:
+        print(f"   요약 결과: {summary}")
+        print(f"   요약 길이: {len(summary)} 문자")
+        compression_ratio = len(summary) / len(test_text.strip())
+        print(f"   압축률: {compression_ratio:.2f}")
+    else:
+        print("   ❌ 요약 실패")
+    
+    print()
+    
+    # 3. 핵심 포인트 추출 테스트
+    print("3. 핵심 포인트 추출 테스트:")
+    key_points = text_summarizer.extract_key_points(test_text, max_points=3)
+    
+    if key_points:
+        print("   추출된 핵심 포인트:")
+        for i, point in enumerate(key_points, 1):
+            print(f"   {i}. {point}")
+    else:
+        print("   ❌ 핵심 포인트 추출 실패")
+    
+    print()
+    
+    # 4. 문서 압축 테스트
+    print("4. 문서 압축 테스트:")
+    long_text = test_text * 3  # 더 긴 텍스트 생성
+    print(f"   원본 텍스트 길이: {len(long_text)} 문자")
+    
+    compressed = text_summarizer.compress_document_content(long_text, target_length=200)
+    
+    if compressed:
+        print(f"   압축 결과: {compressed}")
+        print(f"   압축 길이: {len(compressed)} 문자")
+        compression_ratio = len(compressed) / len(long_text)
+        print(f"   압축률: {compression_ratio:.2f}")
+    else:
+        print("   ❌ 압축 실패")
+    
+    print()
+    print("✅ 테스트 완료!")
+
+if __name__ == "__main__":
+    test_summarizers()