Auto commit at 23-2025-08 10:05:36

lily_llm_api/api/__init__.py

@@ -0,0 +1,3 @@
+"""
+API package for Lily LLM API
+"""

lily_llm_api/api/routers/__init__.py

@@ -0,0 +1,3 @@
+"""
+API Routers package for Lily LLM API
+"""

lily_llm_api/api/routers/advanced_context_router.py

@@ -0,0 +1,302 @@
+"""
+Advanced context management router for Lily LLM API
+"""
+from fastapi import APIRouter, HTTPException, Form
+from typing import Optional
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+@router.post("/context/set-system-prompt")
+async def set_system_prompt(prompt: str = Form(...)):
+    """시스템 프롬프트 설정"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            context_manager.set_system_prompt(prompt)
+            return {
+                "success": True,
+                "message": "시스템 프롬프트가 설정되었습니다.",
+                "prompt_length": len(prompt)
+            }
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 시스템 프롬프트 설정 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.post("/context/add-message")
+async def add_context_message(
+    role: str = Form(...),  # 'user' 또는 'assistant'
+    content: str = Form(...),
+    message_id: str = Form(None),
+    metadata: str = Form("{}")  # JSON 문자열
+):
+    """컨텍스트에 메시지 추가"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            metadata_dict = json.loads(metadata) if metadata else {}
+            
+            if role == "user":
+                msg_id = context_manager.add_user_message(content, message_id, metadata_dict)
+            elif role == "assistant":
+                msg_id = context_manager.add_assistant_message(content, message_id, metadata_dict)
+            else:
+                return {"success": False, "error": "잘못된 역할입니다. 'user' 또는 'assistant'를 사용하세요."}
+            
+            return {
+                "success": True,
+                "message": "메시지가 컨텍스트에 추가되었습니다.",
+                "message_id": msg_id,
+                "context_summary": context_manager.get_context_summary()
+            }
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 메시지 추가 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.get("/context/get")
+async def get_context(
+    include_system: bool = True,
+    max_length: Optional[int] = None,
+    recent_turns: Optional[int] = None
+):
+    """현재 컨텍스트 조회"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if recent_turns:
+                context = context_manager.get_recent_context(recent_turns)
+            else:
+                context = context_manager.get_context(include_system, max_length)
+            
+            return {
+                "success": True,
+                "context": context,
+                "context_summary": context_manager.get_context_summary(),
+                "memory_efficiency": context_manager.get_memory_efficiency()
+            }
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 조회 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.get("/context/summary")
+async def get_context_summary():
+    """컨텍스트 요약 정보 조회"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            return {
+                "success": True,
+                "summary": context_manager.get_context_summary(),
+                "memory_efficiency": context_manager.get_memory_efficiency()
+            }
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 요약 조회 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.post("/context/clear")
+async def clear_context():
+    """컨텍스트 초기화"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            context_manager.clear_context()
+            return {
+                "success": True,
+                "message": "컨텍스트가 초기화되었습니다."
+            }
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 초기화 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.delete("/context/message/{message_id}")
+async def remove_context_message(message_id: str):
+    """컨텍스트에서 특정 메시지 제거"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            success = context_manager.remove_message(message_id)
+            if success:
+                return {
+                    "success": True,
+                    "message": "메시지가 제거되었습니다.",
+                    "context_summary": context_manager.get_context_summary()
+                }
+            else:
+                return {"success": False, "error": "메시지를 찾을 수 없습니다."}
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 메시지 제거 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.put("/context/message/{message_id}")
+async def edit_context_message(
+    message_id: str,
+    new_content: str = Form(...)
+):
+    """컨텍스트 메시지 수정"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            success = context_manager.edit_message(message_id, new_content)
+            if success:
+                return {
+                    "success": True,
+                    "message": "메시지가 수정되었습니다.",
+                    "context_summary": context_manager.get_context_summary()
+                }
+            else:
+                return {"success": False, "error": "메시지를 찾을 수 없습니다."}
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 메시지 수정 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.get("/context/search")
+async def search_context(query: str, max_results: int = 5):
+    """컨텍스트 내에서 검색"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            results = context_manager.search_context(query, max_results)
+            return {
+                "success": True,
+                "query": query,
+                "results": results,
+                "total_results": len(results)
+            }
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 검색 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.post("/context/export")
+async def export_context(file_path: str = Form(None)):
+    """컨텍스트 내보내기"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            exported_path = context_manager.export_context(file_path)
+            return {
+                "success": True,
+                "message": "컨텍스트가 내보내졌습니다.",
+                "file_path": exported_path
+            }
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 내보내기 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.post("/context/import")
+async def import_context(file_path: str = Form(...)):
+    """컨텍스트 가져오기"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            success = context_manager.import_context(file_path)
+            if success:
+                return {
+                    "success": True,
+                    "message": "컨텍스트가 가져와졌습니다.",
+                    "context_summary": context_manager.get_context_summary()
+                }
+            else:
+                return {"success": False, "error": "컨텍스트 가져오기에 실패했습니다."}
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 가져오기 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.post("/context/compress")
+async def compress_context(compression_ratio: float = Form(0.5)):
+    """컨텍스트 압축"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            success = context_manager.compress_context(compression_ratio)
+            if success:
+                return {
+                    "success": True,
+                    "message": "컨텍스트가 압축되었습니다.",
+                    "compression_ratio": compression_ratio,
+                    "context_summary": context_manager.get_context_summary()
+                }
+            else:
+                return {"success": False, "error": "컨텍스트 압축에 실패했습니다."}
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 압축 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.post("/context/optimize")
+async def optimize_context(optimization_strategy: str = Form("memory")):
+    """컨텍스트 최��화"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            success = context_manager.optimize_context(optimization_strategy)
+            if success:
+                return {
+                    "success": True,
+                    "message": "컨텍스트가 최적화되었습니다.",
+                    "strategy": optimization_strategy,
+                    "context_summary": context_manager.get_context_summary()
+                }
+            else:
+                return {"success": False, "error": "컨텍스트 최적화에 실패했습니다."}
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 최적화 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.get("/context/health")
+async def get_context_health():
+    """컨텍스트 시스템 상태 확인"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            health_info = context_manager.get_health_info()
+            return {
+                "success": True,
+                "health": health_info
+            }
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 상태 확인 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.get("/context/analytics")
+async def get_context_analytics():
+    """컨텍스트 분석 정보 조회"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            analytics = context_manager.get_analytics()
+            return {
+                "success": True,
+                "analytics": analytics
+            }
+        except ImportError:
+            return {"success": False, "error": "Context manager not available"}
+    except Exception as e:
+        logger.error(f"❌ 컨텍스트 분석 조회 실패: {e}")
+        return {"success": False, "error": str(e)}

lily_llm_api/api/routers/context_router.py

@@ -0,0 +1,273 @@
+"""
+Context management router for Lily LLM API
+"""
+from fastapi import APIRouter, HTTPException, Form
+from typing import Optional
+import logging
+
+from ...models.schemas import (
+    ContextStatusResponse, ContextHistoryResponse, 
+    AutoCleanupConfigResponse, AutoCleanupConfigRequest
+)
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+@router.get("/context/status", response_model=ContextStatusResponse)
+async def get_context_status():
+    """컨텍스트 관리자 상태 확인"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                return ContextStatusResponse(
+                    status="error",
+                    context_manager_available=False,
+                    total_sessions=0,
+                    sessions={},
+                    max_tokens=0,
+                    max_turns=0,
+                    strategy="unknown",
+                    message="Context manager not available"
+                )
+            
+            # 세션별 정보 수집
+            session_info = {}
+            for session_id, conversation in context_manager.session_conversations.items():
+                session_info[session_id] = {
+                    "turns": len(conversation),
+                    "user_messages": len([t for t in conversation if t.role == "user"]),
+                    "assistant_messages": len([t for t in conversation if t.role == "assistant"])
+                }
+            
+            return ContextStatusResponse(
+                status="success",
+                context_manager_available=True,
+                total_sessions=len(context_manager.session_conversations),
+                sessions=session_info,
+                max_tokens=getattr(context_manager, 'max_tokens', 0),
+                max_turns=getattr(context_manager, 'max_turns', 0),
+                strategy=getattr(context_manager, 'strategy', 'unknown')
+            )
+        except ImportError:
+            return ContextStatusResponse(
+                status="error",
+                context_manager_available=False,
+                total_sessions=0,
+                sessions={},
+                max_tokens=0,
+                max_turns=0,
+                strategy="unknown",
+                message="Context manager import failed"
+            )
+    except Exception as e:
+        logger.error(f"컨텍스트 상태 확인 실패: {e}")
+        return ContextStatusResponse(
+            status="error",
+            context_manager_available=False,
+            total_sessions=0,
+            sessions={},
+            max_tokens=0,
+            max_turns=0,
+            strategy="unknown",
+            message=str(e)
+        )
+
+@router.get("/context/history", response_model=ContextHistoryResponse)
+async def get_context_history(session_id: str = None):
+    """컨텍스트 히스토리 조회"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                return ContextHistoryResponse(
+                    status="error",
+                    context="",
+                    history_length=0,
+                    message="Context manager not available"
+                )
+            
+            if session_id:
+                # 특정 세션의 컨텍스트만 조회
+                context = context_manager.get_context(include_system=True, max_length=4000, session_id=session_id)
+                session_summary = context_manager.get_context_summary(session_id)
+                return ContextHistoryResponse(
+                    status="success",
+                    session_id=session_id,
+                    context=context,
+                    history_length=session_summary.get("total_turns", 0),
+                    session_summary=session_summary
+                )
+            else:
+                # 전체 컨텍스트 조회
+                context = context_manager.get_context(include_system=True, max_length=4000)
+                return ContextHistoryResponse(
+                    status="success",
+                    context=context,
+                    history_length=len(context_manager.conversation_history),
+                    all_sessions=True
+                )
+        except ImportError:
+            return ContextHistoryResponse(
+                status="error",
+                context="",
+                history_length=0,
+                message="Context manager import failed"
+            )
+    except Exception as e:
+        logger.error(f"컨텍스트 히스토리 조회 실패: {e}")
+        return ContextHistoryResponse(
+            status="error",
+            context="",
+            history_length=0,
+            message=str(e)
+        )
+
+@router.get("/context/auto-cleanup", response_model=AutoCleanupConfigResponse)
+async def get_auto_cleanup_config():
+    """자동 정리 설정 조회"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                return AutoCleanupConfigResponse(
+                    status="error",
+                    auto_cleanup_config={},
+                    message="Context manager not available"
+                )
+            
+            config = context_manager.get_auto_cleanup_config()
+            return AutoCleanupConfigResponse(
+                status="success",
+                auto_cleanup_config=config
+            )
+        except ImportError:
+            return AutoCleanupConfigResponse(
+                status="error",
+                auto_cleanup_config={},
+                message="Context manager import failed"
+            )
+    except Exception as e:
+        logger.error(f"자동 정리 설정 조회 실패: {e}")
+        return AutoCleanupConfigResponse(
+            status="error",
+            auto_cleanup_config={},
+            message=str(e)
+        )
+
+@router.post("/context/auto-cleanup")
+async def set_auto_cleanup_config(
+    enabled: bool = Form(True),
+    interval_turns: int = Form(8),
+    interval_time: int = Form(300),
+    strategy: str = Form("smart")
+):
+    """자동 정리 설정 변경"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                raise HTTPException(status_code=500, detail="Context manager not available")
+            
+            success = context_manager.set_auto_cleanup_config(
+                enabled=enabled,
+                interval_turns=interval_turns,
+                interval_time=interval_time,
+                strategy=strategy
+            )
+            
+            if success:
+                return {"status": "success", "message": "자동 정리 설정 변경 완료"}
+            else:
+                raise HTTPException(status_code=500, detail="자동 정리 설정 변경 실패")
+        except ImportError:
+            raise HTTPException(status_code=500, detail="Context manager import failed")
+    except Exception as e:
+        logger.error(f"자동 정리 설정 변경 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"자동 정리 설정 변경 실패: {str(e)}")
+
+@router.post("/context/cleanup")
+async def cleanup_context(session_id: str = Form(None)):
+    """컨텍스트 정리"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                raise HTTPException(status_code=500, detail="Context manager not available")
+            
+            if session_id:
+                # 특정 세션 정리
+                success = context_manager.cleanup_session(session_id)
+                if success:
+                    return {"status": "success", "message": f"세션 {session_id} 정리 완료"}
+                else:
+                    raise HTTPException(status_code=500, detail=f"세션 {session_id} 정리 실패")
+            else:
+                # 전체 컨텍스트 정리
+                success = context_manager.cleanup_context()
+                if success:
+                    return {"status": "success", "message": "전체 컨텍스트 정리 완료"}
+                else:
+                    raise HTTPException(status_code=500, detail="전체 컨텍스트 정리 실패")
+        except ImportError:
+            raise HTTPException(status_code=500, detail="Context manager import failed")
+    except Exception as e:
+        logger.error(f"컨텍스트 정리 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"컨텍스트 정리 실패: {str(e)}")
+
+@router.post("/context/summary")
+async def generate_context_summary(session_id: str = Form(...)):
+    """컨텍스트 요약 생성"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                raise HTTPException(status_code=500, detail="Context manager not available")
+            
+            summary = context_manager.generate_summary(session_id)
+            if summary:
+                return {"status": "success", "summary": summary}
+            else:
+                raise HTTPException(status_code=500, detail="컨텍스트 요약 생성 실패")
+        except ImportError:
+            raise HTTPException(status_code=500, detail="Context manager import failed")
+    except Exception as e:
+        logger.error(f"컨텍스트 요약 생성 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"컨텍스트 요약 생성 실패: {str(e)}")
+
+@router.delete("/context/session/{session_id}")
+async def delete_session(session_id: str):
+    """특정 세션 삭제"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                raise HTTPException(status_code=500, detail="Context manager not available")
+            
+            success = context_manager.delete_session(session_id)
+            if success:
+                return {"status": "success", "message": f"세션 {session_id} 삭제 완료"}
+            else:
+                raise HTTPException(status_code=500, detail=f"세션 {session_id} 삭제 실패")
+        except ImportError:
+            raise HTTPException(status_code=500, detail="Context manager import failed")
+    except Exception as e:
+        logger.error(f"세션 삭제 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"세션 삭제 실패: {str(e)}")
+
+@router.get("/context/sessions")
+async def list_sessions():
+    """사용 가능한 세션 목록"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                raise HTTPException(status_code=500, detail="Context manager not available")
+            
+            sessions = list(context_manager.session_conversations.keys())
+            return {"status": "success", "sessions": sessions}
+        except ImportError:
+            raise HTTPException(status_code=500, detail="Context manager import failed")
+    except Exception as e:
+        logger.error(f"세션 목록 조회 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"세션 목록 조회 실패: {str(e)}")

lily_llm_api/api/routers/document_router.py

@@ -0,0 +1,434 @@
+"""
+Document processing and RAG router for Lily LLM API
+"""
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from typing import Optional, List
+import logging
+import time
+
+from ...models.schemas import (
+    DocumentUploadResponse, RAGQueryRequest, RAGQueryResponse,
+    DocumentProcessResponse, MultimodalRAGResponse
+)
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+@router.post("/document/upload", response_model=DocumentUploadResponse)
+async def upload_document(
+    file: UploadFile = File(...),
+    user_id: str = Form("anonymous"),
+    room_id: str = Form("default")
+):
+    """문서 업로드 및 처리"""
+    try:
+        start_time = time.time()
+        
+        # 파일 읽기
+        content = await file.read()
+        filename = file.filename
+        
+        # 문서 처리기 사용
+        try:
+            from lily_llm_core.document_processor import document_processor
+            
+            # 문서 처리
+            result = document_processor.process_document(
+                content=content,
+                filename=filename,
+                user_id=user_id,
+                room_id=room_id
+            )
+            
+            if result.get("success"):
+                processing_time = time.time() - start_time
+                return DocumentUploadResponse(
+                    success=True,
+                    document_id=result.get("document_id", "unknown"),
+                    message="문서 업로드 및 처리 완료",
+                    chunks=result.get("chunks", 0),
+                    latex_count=result.get("latex_count", 0),
+                    auto_response=result.get("auto_response")
+                )
+            else:
+                return DocumentUploadResponse(
+                    success=False,
+                    document_id="",
+                    message="문서 처리 실패",
+                    error=result.get("error", "Unknown error")
+                )
+                
+        except ImportError:
+            return DocumentUploadResponse(
+                success=False,
+                document_id="",
+                message="문서 처리기 import 실패",
+                error="Document processor not available"
+            )
+            
+    except Exception as e:
+        logger.error(f"문서 업로드 실패: {e}")
+        return DocumentUploadResponse(
+            success=False,
+            document_id="",
+            message="문서 업로드 중 오류 발생",
+            error=str(e)
+        )
+
+@router.post("/rag/query", response_model=RAGQueryResponse)
+async def rag_query(
+    query: str = Form(...),
+    user_id: str = Form("anonymous"),
+    room_id: str = Form("default"),
+    max_results: int = Form(5),
+    include_sources: bool = Form(True)
+):
+    """RAG 쿼리 처리"""
+    try:
+        start_time = time.time()
+        
+        try:
+            from lily_llm_core.rag_processor import rag_processor
+            
+            # RAG 쿼리 실행
+            result = rag_processor.query(
+                query=query,
+                user_id=user_id,
+                room_id=room_id,
+                max_results=max_results,
+                include_sources=include_sources
+            )
+            
+            if result.get("success"):
+                processing_time = time.time() - start_time
+                return RAGQueryResponse(
+                    success=True,
+                    response=result.get("response", ""),
+                    sources=result.get("sources", []),
+                    search_results=len(result.get("sources", [])),
+                    processing_time=processing_time
+                )
+            else:
+                return RAGQueryResponse(
+                    success=False,
+                    response="",
+                    sources=[],
+                    search_results=0,
+                    processing_time=0,
+                    error=result.get("error", "RAG 쿼리 실패")
+                )
+                
+        except ImportError:
+            return RAGQueryResponse(
+                success=False,
+                response="",
+                sources=[],
+                search_results=0,
+                processing_time=0,
+                error="RAG processor not available"
+            )
+            
+    except Exception as e:
+        logger.error(f"RAG 쿼리 실패: {e}")
+        return RAGQueryResponse(
+            success=False,
+            response="",
+            sources=[],
+            search_results=0,
+            processing_time=0,
+            error=str(e)
+        )
+
+@router.post("/rag/generate", response_model=RAGQueryResponse)
+async def rag_generate(
+    prompt: str = Form(...),
+    user_id: str = Form("anonymous"),
+    room_id: str = Form("default"),
+    max_results: int = Form(5)
+):
+    """RAG 기반 텍스트 생성"""
+    try:
+        start_time = time.time()
+        
+        try:
+            from lily_llm_core.rag_processor import rag_processor
+            
+            # RAG 생성 실행
+            result = rag_processor.generate_with_context(
+                prompt=prompt,
+                user_id=user_id,
+                room_id=room_id,
+                max_results=max_results
+            )
+            
+            if result.get("success"):
+                processing_time = time.time() - start_time
+                return RAGQueryResponse(
+                    success=True,
+                    response=result.get("response", ""),
+                    sources=result.get("sources", []),
+                    search_results=len(result.get("sources", [])),
+                    processing_time=processing_time
+                )
+            else:
+                return RAGQueryResponse(
+                    success=False,
+                    response="",
+                    sources=[],
+                    search_results=0,
+                    processing_time=0,
+                    error=result.get("error", "RAG 생성 실패")
+                )
+                
+        except ImportError:
+            return RAGQueryResponse(
+                success=False,
+                response="",
+                sources=[],
+                search_results=0,
+                processing_time=0,
+                error="RAG processor not available"
+            )
+            
+    except Exception as e:
+        logger.error(f"RAG 생성 실패: {e}")
+        return RAGQueryResponse(
+            success=False,
+            response="",
+            sources=[],
+            search_results=0,
+            processing_time=0,
+            error=str(e)
+        )
+
+@router.post("/rag/summary")
+async def generate_rag_summary(
+    user_id: str = Form("anonymous"),
+    room_id: str = Form("default")
+):
+    """RAG 문서 요약 생성"""
+    try:
+        try:
+            from lily_llm_core.rag_processor import rag_processor
+            
+            # RAG 요약 생성
+            result = rag_processor.generate_summary(
+                user_id=user_id,
+                room_id=room_id
+            )
+            
+            if result.get("success"):
+                return {"status": "success", "summary": result.get("summary", "")}
+            else:
+                raise HTTPException(status_code=500, detail=result.get("error", "RAG 요약 생성 실패"))
+                
+        except ImportError:
+            raise HTTPException(status_code=500, detail="RAG processor not available")
+            
+    except Exception as e:
+        logger.error(f"RAG 요약 생성 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"RAG 요약 생성 실패: {str(e)}")
+
+@router.post("/rag/clear")
+async def clear_rag_context(
+    user_id: str = Form("anonymous"),
+    room_id: str = Form("default")
+):
+    """RAG 컨텍스트 정리"""
+    try:
+        try:
+            from lily_llm_core.rag_processor import rag_processor
+            
+            # RAG 컨텍스트 정리
+            success = rag_processor.clear_context(
+                user_id=user_id,
+                room_id=room_id
+            )
+            
+            if success:
+                return {"status": "success", "message": "RAG 컨텍스트 정리 완료"}
+            else:
+                raise HTTPException(status_code=500, detail="RAG 컨텍스트 정리 실패")
+                
+        except ImportError:
+            raise HTTPException(status_code=500, detail="RAG processor not available")
+            
+    except Exception as e:
+        logger.error(f"RAG 컨텍스트 정리 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"RAG 컨텍스트 정리 실패: {str(e)}")
+
+@router.post("/rag/batch-process")
+async def batch_process_documents(
+    files: List[UploadFile] = File(...),
+    user_id: str = Form("anonymous"),
+    room_id: str = Form("default")
+):
+    """여러 문서 일괄 처리"""
+    try:
+        start_time = time.time()
+        results = []
+        
+        try:
+            from lily_llm_core.document_processor import document_processor
+            
+            for file in files:
+                content = await file.read()
+                filename = file.filename
+                
+                result = document_processor.process_document(
+                    content=content,
+                    filename=filename,
+                    user_id=user_id,
+                    room_id=room_id
+                )
+                
+                results.append({
+                    "filename": filename,
+                    "success": result.get("success", False),
+                    "document_id": result.get("document_id", ""),
+                    "chunks": result.get("chunks", 0),
+                    "error": result.get("error")
+                })
+            
+            processing_time = time.time() - start_time
+            return {
+                "status": "success",
+                "results": results,
+                "total_files": len(files),
+                "processing_time": processing_time
+            }
+            
+        except ImportError:
+            raise HTTPException(status_code=500, detail="Document processor not available")
+            
+    except Exception as e:
+        logger.error(f"일괄 문서 처리 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"일괄 문서 처리 실패: {str(e)}")
+
+@router.get("/rag/search-history")
+async def search_rag_history(
+    user_id: str = "anonymous",
+    room_id: str = "default",
+    query: str = "",
+    limit: int = 10
+):
+    """RAG 검색 히스토리 조회"""
+    try:
+        try:
+            from lily_llm_core.rag_processor import rag_processor
+            
+            # RAG 검색 히스토리 조회
+            history = rag_processor.get_search_history(
+                user_id=user_id,
+                room_id=room_id,
+                query=query,
+                limit=limit
+            )
+            
+            return {"status": "success", "history": history}
+            
+        except ImportError:
+            raise HTTPException(status_code=500, detail="RAG processor not available")
+            
+    except Exception as e:
+        logger.error(f"RAG 검색 히스토리 조회 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"RAG 검색 히스토리 조회 실패: {str(e)}")
+
+@router.post("/multimodal-rag/upload")
+async def upload_multimodal_document(
+    file: UploadFile = File(...),
+    user_id: str = Form("anonymous"),
+    room_id: str = Form("default")
+):
+    """멀티모달 문서 업로드"""
+    try:
+        start_time = time.time()
+        
+        # 파일 읽기
+        content = await file.read()
+        filename = file.filename
+        
+        try:
+            from lily_llm_core.hybrid_rag_processor import hybrid_rag_processor
+            
+            # 멀티모달 문서 처리
+            result = hybrid_rag_processor.process_document(
+                content=content,
+                filename=filename,
+                user_id=user_id,
+                room_id=room_id
+            )
+            
+            if result.get("success"):
+                processing_time = time.time() - start_time
+                return {
+                    "status": "success",
+                    "document_id": result.get("document_id", ""),
+                    "processing_time": processing_time,
+                    "message": "멀티모달 문서 업로드 완료"
+                }
+            else:
+                raise HTTPException(status_code=500, detail=result.get("error", "멀티모달 문서 처리 실패"))
+                
+        except ImportError:
+            raise HTTPException(status_code=500, detail="Hybrid RAG processor not available")
+            
+    except Exception as e:
+        logger.error(f"멀티모달 문서 업로드 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"멀티모달 문서 업로드 실패: {str(e)}")
+
+@router.post("/multimodal-rag/generate", response_model=MultimodalRAGResponse)
+async def generate_multimodal_rag(
+    prompt: str = Form(...),
+    user_id: str = Form("anonymous"),
+    room_id: str = Form("default")
+):
+    """멀티모달 RAG 기반 텍스트 생성"""
+    try:
+        start_time = time.time()
+        
+        try:
+            from lily_llm_core.hybrid_rag_processor import hybrid_rag_processor
+            
+            # 멀티모달 RAG 생성
+            result = hybrid_rag_processor.generate(
+                prompt=prompt,
+                user_id=user_id,
+                room_id=room_id
+            )
+            
+            if result.get("success"):
+                processing_time = time.time() - start_time
+                return MultimodalRAGResponse(
+                    success=True,
+                    response=result.get("response", ""),
+                    image_processed=result.get("image_processed", False),
+                    processing_time=processing_time
+                )
+            else:
+                return MultimodalRAGResponse(
+                    success=False,
+                    response="",
+                    image_processed=False,
+                    processing_time=0,
+                    error=result.get("error", "멀티모달 RAG 생성 실패")
+                )
+                
+        except ImportError:
+            return MultimodalRAGResponse(
+                success=False,
+                response="",
+                image_processed=False,
+                processing_time=0,
+                error="Hybrid RAG processor not available"
+            )
+            
+    except Exception as e:
+        logger.error(f"멀티모달 RAG 생성 실패: {e}")
+        return MultimodalRAGResponse(
+            success=False,
+            response="",
+            image_processed=False,
+            processing_time=0,
+            error=str(e)
+        )

lily_llm_api/api/routers/generation_router.py

@@ -0,0 +1,128 @@
+"""
+Generation router for Lily LLM API
+"""
+from fastapi import APIRouter, HTTPException, Request, UploadFile, File, Form, Depends
+from typing import Optional, List
+import logging
+import time
+
+from ...models.schemas import GenerateResponse, MultimodalGenerateResponse
+from ...services.generation_service import generate_sync
+from ...services.model_service import is_model_loaded
+from ...utils.system_utils import select_model_interactive
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+@router.post("/generate", response_model=GenerateResponse)
+async def generate(request: Request,
+                  prompt: str = Form(...), 
+                  image1: UploadFile = File(None),
+                  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)):
+    
+    if not is_model_loaded():
+        raise HTTPException(status_code=503, detail="모델이 로드되지 않았습니다.")
+
+    start_time = time.time()
+
+    # 세션 ID가 없으면 자동 생성 (채팅방별 고유 세션)
+    if not session_id:
+        # 채팅방 + 사용자 + 타임스탬프 기반으로 고유한 세션 생성
+        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:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            context_manager.add_user_message(prompt, metadata={"session_id": session_id})
+            print(f"🔍 [DEBUG] 사용자 메시지 추가됨 (세션: {session_id})")
+        except Exception as e:
+            logger.warning(f"⚠️ 컨텍스트 관리자 사용 불가: {e}")
+
+    # 이미지 데이터 처리
+    image_data_list = []
+    for img_file in [image1, image2, image3, image4]:
+        if img_file:
+            try:
+                data = await img_file.read()
+                image_data_list.append(data)
+            except Exception as e:
+                logger.warning(f"이미지 로드 실패: {e}")
+
+    try:
+        # generate_sync 함수 호출 (컨텍스트 포함)
+        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"])
+        
+        if use_context:
+            try:
+                from lily_llm_core.context_manager import context_manager
+                context_manager.add_assistant_message(result["generated_text"], metadata={"session_id": session_id})
+            except Exception as e:
+                logger.warning(f"⚠️ 컨텍스트 관리자 사용 불가: {e}")
+
+        return GenerateResponse(
+            generated_text=result["generated_text"],
+            processing_time=result["processing_time"],
+            model_name=result["model_name"],
+            image_processed=result["image_processed"]
+        )
+        
+    except Exception as e:
+        logger.error(f"❌ 생성 중 오류 발생: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"모델 생성 중 오류 발생: {str(e)}")
+
+
+@router.post("/generate-multimodal", response_model=MultimodalGenerateResponse)
+async def generate_multimodal(prompt: str = Form(...),
+                             image: UploadFile = File(None),
+                             model_id: Optional[str] = Form(None),
+                             max_length: Optional[int] = Form(None),
+                             temperature: Optional[float] = Form(None),
+                             top_p: Optional[float] = Form(None),
+                             do_sample: Optional[bool] = Form(None)):
+    
+    if not is_model_loaded():
+        raise HTTPException(status_code=500, detail="모델이 로드되지 않았습니다")
+
+    start_time = time.time()
+
+    # 이미지 데이터 처리
+    image_data_list = []
+    if image:
+        try:
+            data = await image.read()
+            image_data_list.append(data)
+        except Exception as e:
+            logger.error(f"이미지 처리 실패: {e}")
+
+    try:
+        # generate_sync 함수 호출
+        result = generate_sync(prompt, image_data_list, max_length=max_length, 
+                             temperature=temperature, top_p=top_p, do_sample=do_sample)
+        
+        if "error" in result:
+            raise HTTPException(status_code=500, detail=result["error"])
+        
+        from ...services.model_service import get_current_profile
+        current_profile = get_current_profile()
+        
+        return MultimodalGenerateResponse(
+            generated_text=result["generated_text"],
+            processing_time=result["processing_time"],
+            model_name=current_profile.display_name,
+            model_id=model_id or current_profile.get_model_info().get("model_name"),
+            image_processed=bool(image_data_list)
+        )
+    except Exception as e:
+        logger.error(f"❌ 멀티모달 생성 오류: {e}")
+        raise HTTPException(status_code=500, detail=f"멀티모달 생성 실패: {str(e)}")

lily_llm_api/api/routers/lora_router.py

@@ -0,0 +1,223 @@
+"""
+LoRA router for Lily LLM API
+"""
+from fastapi import APIRouter, HTTPException, Form, UploadFile, File
+from typing import Optional
+import logging
+
+from ...models.schemas import LoRAStatusResponse
+from ...utils.lora_utils import setup_lora_for_model
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+@router.get("/lora/status", response_model=LoRAStatusResponse)
+async def get_lora_status():
+    """현재 LoRA 상태 확인"""
+    try:
+        try:
+            from lily_llm_core.lora_manager import lora_manager
+            if lora_manager is None:
+                return LoRAStatusResponse(
+                    status="error",
+                    lora_available=False,
+                    base_model_loaded=False,
+                    device="unknown",
+                    message="LoRA 기능이 사용 불가능합니다"
+                )
+            
+            return LoRAStatusResponse(
+                status="success",
+                lora_available=True,
+                current_adapter=getattr(lora_manager, 'current_adapter_name', None),
+                base_model_loaded=hasattr(lora_manager, 'base_model') and lora_manager.base_model is not None,
+                device=getattr(lora_manager, 'device', 'unknown')
+            )
+        except ImportError:
+            return LoRAStatusResponse(
+                status="error",
+                lora_available=False,
+                base_model_loaded=False,
+                device="unknown",
+                message="LoRA 관리자 import 실패"
+            )
+    except Exception as e:
+        logger.error(f"LoRA 상태 확인 실패: {e}")
+        return LoRAStatusResponse(
+            status="error",
+            lora_available=False,
+            base_model_loaded=False,
+            device="unknown",
+            message=str(e)
+        )
+
+@router.post("/lora/load-base-model")
+async def load_base_model(model_path: str = Form(...)):
+    """LoRA 기본 모델 로드"""
+    try:
+        from lily_llm_core.lora_manager import lora_manager
+        if not lora_manager:
+            raise HTTPException(status_code=500, detail="LoRA 관리자를 사용할 수 없습니다")
+        
+        success = lora_manager.load_base_model(model_path)
+        if success:
+            return {"status": "success", "message": f"기본 모델 로드 완료: {model_path}"}
+        else:
+            raise HTTPException(status_code=500, detail="기본 모델 로드 실패")
+    except Exception as e:
+        logger.error(f"LoRA 기본 모델 로드 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"LoRA 기본 모델 로드 실패: {str(e)}")
+
+@router.post("/lora/create-config")
+async def create_lora_config(
+    r: int = Form(16),
+    lora_alpha: int = Form(32),
+    lora_dropout: float = Form(0.1),
+    bias: str = Form("none"),
+    task_type: str = Form("CAUSAL_LM"),
+    target_modules: str = Form("query_key_value")
+):
+    """LoRA 설정 생성"""
+    try:
+        from lily_llm_core.lora_manager import lora_manager
+        if not lora_manager:
+            raise HTTPException(status_code=500, detail="LoRA 관리자를 사용할 수 없습니다")
+        
+        # target_modules를 리스트로 변환
+        target_modules_list = [m.strip() for m in target_modules.split(",")]
+        
+        config = lora_manager.create_lora_config(
+            r=r,
+            lora_alpha=lora_alpha,
+            lora_dropout=lora_dropout,
+            bias=bias,
+            task_type=task_type,
+            target_modules=target_modules_list
+        )
+        
+        return {"status": "success", "config": config}
+    except Exception as e:
+        logger.error(f"LoRA 설정 생성 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"LoRA 설정 생성 실패: {str(e)}")
+
+@router.post("/lora/apply")
+async def apply_lora(adapter_name: str = Form(...)):
+    """LoRA 어댑터 적용"""
+    try:
+        from lily_llm_core.lora_manager import lora_manager
+        if not lora_manager:
+            raise HTTPException(status_code=500, detail="LoRA 관리자를 사용할 수 없습니다")
+        
+        success = lora_manager.apply_lora_to_model(adapter_name)
+        if success:
+            return {"status": "success", "message": f"LoRA 어댑터 적용 완료: {adapter_name}"}
+        else:
+            raise HTTPException(status_code=500, detail="LoRA 어댑터 적용 실패")
+    except Exception as e:
+        logger.error(f"LoRA 어댑터 적용 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"LoRA 어댑터 적용 실패: {str(e)}")
+
+@router.get("/lora/adapters")
+async def list_lora_adapters():
+    """사용 가능한 LoRA 어댑터 목록"""
+    try:
+        from lily_llm_core.lora_manager import lora_manager
+        if not lora_manager:
+            raise HTTPException(status_code=500, detail="LoRA 관리자를 사용할 수 없습니다")
+        
+        adapters = lora_manager.list_adapters()
+        return {"status": "success", "adapters": adapters}
+    except Exception as e:
+        logger.error(f"LoRA 어댑터 목록 조회 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"LoRA 어댑터 목록 조회 실패: {str(e)}")
+
+@router.get("/lora/stats")
+async def get_lora_stats():
+    """LoRA 통계 정보"""
+    try:
+        from lily_llm_core.lora_manager import lora_manager
+        if not lora_manager:
+            raise HTTPException(status_code=500, detail="LoRA 관리자를 사용할 수 없습니다")
+        
+        stats = lora_manager.get_stats()
+        return {"status": "success", "stats": stats}
+    except Exception as e:
+        logger.error(f"LoRA 통계 조회 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"LoRA 통계 조회 실패: {str(e)}")
+
+@router.post("/lora/switch")
+async def switch_lora_adapter(adapter_name: str = Form(...)):
+    """LoRA 어댑터 전환"""
+    try:
+        from lily_llm_core.lora_manager import lora_manager
+        if not lora_manager:
+            raise HTTPException(status_code=500, detail="LoRA 관리자를 사용할 수 없습니다")
+        
+        success = lora_manager.switch_adapter(adapter_name)
+        if success:
+            return {"status": "success", "message": f"LoRA 어댑터 전환 완료: {adapter_name}"}
+        else:
+            raise HTTPException(status_code=500, detail="LoRA 어댑터 전환 실패")
+    except Exception as e:
+        logger.error(f"LoRA 어댑터 전환 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"LoRA 어댑터 전환 실패: {str(e)}")
+
+@router.post("/lora/unload")
+async def unload_lora_adapter():
+    """LoRA 어댑터 언로드"""
+    try:
+        from lily_llm_core.lora_manager import lora_manager
+        if not lora_manager:
+            raise HTTPException(status_code=500, detail="LoRA 관리자를 사용할 수 없습니다")
+        
+        success = lora_manager.unload_adapter()
+        if success:
+            return {"status": "success", "message": "LoRA 어댑터 언로드 완료"}
+        else:
+            raise HTTPException(status_code=500, detail="LoRA 어댑터 언로드 실패")
+    except Exception as e:
+        logger.error(f"LoRA 어댑터 언로드 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"LoRA 어댑터 언로드 실패: {str(e)}")
+
+@router.post("/lora/generate")
+async def generate_with_lora(
+    prompt: str = Form(...),
+    max_length: int = Form(100),
+    temperature: float = Form(0.7)
+):
+    """LoRA가 적용된 모델로 텍스트 생성"""
+    try:
+        from lily_llm_core.lora_manager import lora_manager
+        if not lora_manager:
+            raise HTTPException(status_code=500, detail="LoRA 관리자를 사용할 수 없습니다")
+        
+        if not lora_manager.current_adapter_name:
+            raise HTTPException(status_code=400, detail="로드된 LoRA 어댑터가 없습니다")
+        
+        result = lora_manager.generate_text(
+            prompt=prompt,
+            max_length=max_length,
+            temperature=temperature
+        )
+        
+        return {"status": "success", "generated_text": result}
+    except Exception as e:
+        logger.error(f"LoRA 텍스트 생성 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"LoRA 텍스트 생성 실패: {str(e)}")
+
+@router.post("/lora/merge")
+async def merge_lora_with_base():
+    """LoRA 어댑터를 기본 모델과 병합"""
+    try:
+        from lily_llm_core.lora_manager import lora_manager
+        if not lora_manager:
+            raise HTTPException(status_code=500, detail="LoRA 관리자를 사용할 수 없습니다")
+        
+        success = lora_manager.merge_adapter_with_base()
+        if success:
+            return {"status": "success", "message": "LoRA 어댑터 병합 완료"}
+        else:
+            raise HTTPException(status_code=500, detail="LoRA 어댑터 병합 실패")
+    except Exception as e:
+        logger.error(f"LoRA 어댑터 병합 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"LoRA 어댑터 병합 실패: {str(e)}")

lily_llm_api/api/routers/model_router.py

@@ -0,0 +1,56 @@
+"""
+Model router for Lily LLM API
+"""
+from fastapi import APIRouter, HTTPException, Form
+from typing import Optional
+import logging
+
+from ...models.schemas import HealthResponse
+from ...services.model_service import load_model_async, get_current_profile, is_model_loaded
+from ...models import list_available_models
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+@router.post("/load-model")
+async def load_model_endpoint(model_id: str):
+    """모델 로드 HTTP 엔드포인트"""
+    try:
+        logger.info(f"📥 HTTP 요청으로 모델 로드 시작: {model_id}")
+        await load_model_async(model_id)
+        return {"success": True, "message": f"모델 '{model_id}' 로드 완료"}
+    except Exception as e:
+        logger.error(f"❌ HTTP 모델 로드 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.get("/models")
+async def list_models():
+    """사용 가능한 모델 목록"""
+    return {
+        "models": list_available_models(),
+        "current_model": get_current_profile().get_model_info() if get_current_profile() else None
+    }
+
+@router.post("/switch-model")
+async def switch_model(model_id: str):
+    """모델 변경"""
+    try:
+        await load_model_async(model_id)
+        return {
+            "message": f"모델 변경 성공: {model_id}",
+            "current_model": get_current_profile().display_name
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"모델 변경 실패: {str(e)}")
+    
+@router.get("/health", response_model=HealthResponse)
+async def health_check():
+    """헬스 체크 엔드포인트"""
+    available_models = list_available_models()
+    
+    return HealthResponse(
+        status="healthy",
+        model_loaded=is_model_loaded(),
+        current_model=get_current_profile().display_name if get_current_profile() else "None",
+        available_models=available_models
+    )

lily_llm_api/api/routers/multimodal_rag_router.py

@@ -0,0 +1,567 @@
+"""
+Multimodal RAG router for Lily LLM API
+"""
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from typing import Optional, List
+import logging
+import time
+from pathlib import Path
+
+from ...models.schemas import DocumentUploadResponse, RAGResponse
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+# ============================================================================
+# 멀티모달 RAG 시스템 엔드포인트
+# ============================================================================
+
+@router.post("/hybrid-rag/upload", response_model=DocumentUploadResponse)
+async def upload_hybrid_document(
+    file: UploadFile = File(...),
+    user_id: str = Form("default_user"),
+    document_id: Optional[str] = Form(None)
+):
+    """멀티모달 RAG 문서 업로드"""
+    try:
+        # 파일 저장
+        upload_dir = Path("uploads/hybrid_rag")
+        upload_dir.mkdir(parents=True, exist_ok=True)
+        
+        if not document_id:
+            document_id = f"{user_id}_{int(time.time())}_{file.filename}"
+        
+        file_path = upload_dir / document_id
+        with open(file_path, "wb") as buffer:
+            content = await file.read()
+            buffer.write(content)
+        
+        # 멀티모달 처리
+        try:
+            from lily_llm_core.hybrid_rag_processor import hybrid_rag_processor
+            result = hybrid_rag_processor.process_document_hybrid(str(file_path), user_id, document_id)
+        except ImportError:
+            result = {
+                "success": False,
+                "error": "Hybrid RAG processor not available"
+            }
+        
+        if result["success"]:
+            # 성공한 시스템 수 계산
+            success_systems = []
+            for key, value in result.items():
+                if key.endswith('_processing') and value and value.get('success', False):
+                    system_name = key.replace('_processing', '').replace('_', ' ').title()
+                    success_systems.append(system_name)
+            
+            return DocumentUploadResponse(
+                success=True,
+                document_id=document_id,
+                message=f"멀티모달 처리 완료: {', '.join(success_systems)} 시스템에서 처리됨",
+                chunks=len(success_systems)
+            )
+        else:
+            return DocumentUploadResponse(
+                success=False,
+                error=result.get("error", "멀티모달 처리 실패")
+            )
+            
+    except Exception as e:
+        logger.error(f"멀티모달 RAG 문서 업로드 오류: {e}")
+        return DocumentUploadResponse(
+            success=False,
+            error=f"업로드 중 오류가 발생했습니다: {str(e)}"
+        )
+
+@router.post("/hybrid-rag/generate", response_model=RAGResponse)
+async def generate_hybrid_rag_response(
+    query: str = Form(...),
+    user_id: str = Form("default_user"),
+    document_id: str = Form(...),
+    use_text: bool = Form(True),
+    use_image: bool = Form(True),
+    use_latex: bool = Form(True),
+    use_latex_ocr: bool = Form(False),  # LaTeX-OCR 기능이 비활성화됨
+    max_length: Optional[int] = Form(None),
+    temperature: Optional[float] = Form(None),
+    top_p: Optional[float] = Form(None),
+    do_sample: Optional[bool] = Form(None)
+):
+    """멀티모달 RAG 응답 생성"""
+    try:
+        try:
+            from lily_llm_core.hybrid_rag_processor import hybrid_rag_processor
+            result = hybrid_rag_processor.generate_hybrid_response(
+                query, user_id, document_id,
+                use_text, use_image, use_latex, use_latex_ocr,
+                max_length, temperature, top_p, do_sample
+            )
+        except ImportError:
+            result = {
+                "success": False,
+                "response": "Hybrid RAG processor not available",
+                "context": "",
+                "sources": [],
+                "search_results": 0,
+                "processing_time": 0.0
+            }
+        
+        return RAGResponse(
+            success=result["success"],
+            response=result["response"],
+            context=result["context"],
+            sources=result["sources"],
+            search_results=result["search_results"],
+            processing_time=result["processing_time"]
+        )
+        
+    except Exception as e:
+        logger.error(f"멀티모달 RAG 응답 생성 오류: {e}")
+        return RAGResponse(
+            success=False,
+            response=f"멀티모달 RAG 응답 생성 중 오류가 발생했습니다: {str(e)}",
+            context="",
+            sources=[],
+            search_results=0,
+            processing_time=0.0
+        )
+
+@router.get("/hybrid-rag/document/{user_id}/{document_id}")
+async def get_hybrid_document_info(user_id: str, document_id: str):
+    """멀티모달 RAG 문서 정보 조회"""
+    try:
+        try:
+            from lily_llm_core.hybrid_rag_processor import hybrid_rag_processor
+            result = hybrid_rag_processor.get_document_info(user_id, document_id)
+        except ImportError:
+            result = {"success": False, "error": "Hybrid RAG processor not available"}
+        return result
+    except Exception as e:
+        logger.error(f"멀티모달 RAG 문서 정보 조회 오류: {e}")
+        return {"success": False, "error": str(e)}
+
+@router.get("/hybrid-rag/status")
+async def get_hybrid_rag_status():
+    """멀티모달 RAG 시스템 상태 확인"""
+    try:
+        return {
+            "text_rag_available": True,
+            "image_rag_available": True,
+            "latex_rag_available": True,
+            "latex_ocr_faiss_available": False,  # LaTeX-OCR 기능이 비활성화됨
+            "status": "ready"
+        }
+    except Exception as e:
+        logger.error(f"멀티모달 RAG 상태 확인 오류: {e}")
+        return {"status": "error", "error": str(e)}
+
+# ============================================================================
+# RAG 시스템과 고급 컨텍스트 관리자 통합 API
+# ============================================================================
+
+@router.post("/rag/context-integrated/query")
+async def rag_query_with_context_integration(
+    user_id: str = Form(...),
+    document_id: str = Form(...),
+    query: str = Form(...),
+    session_id: str = Form(...),
+    max_results: int = Form(5),
+    enable_context_integration: bool = Form(True)
+):
+    """RAG 쿼리 + 컨텍스트 통합 - 고급 컨텍스트 관리자와 연동"""
+    try:
+        logger.info(f"🔍 RAG + 컨텍스트 통합 쿼리 시작: 사용자 {user_id}, 문서 {document_id}, 세션 {session_id}")
+        
+        # 컨텍스트 관리자 확인
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                return {"status": "error", "message": "컨텍스트 관리자를 사용할 수 없습니다."}
+        except ImportError:
+            return {"status": "error", "message": "Context manager not available"}
+        
+        # RAG 응답 생성 (컨텍스트 통합 활성화)
+        try:
+            from lily_llm_core.rag_processor import rag_processor
+            rag_result = rag_processor.generate_rag_response(
+                user_id=user_id,
+                document_id=document_id,
+                query=query,
+                session_id=session_id if enable_context_integration else None,
+                context_manager=context_manager if enable_context_integration else None
+            )
+        except ImportError:
+            rag_result = {"success": False, "error": "RAG processor not available"}
+        
+        if not rag_result["success"]:
+            return rag_result
+        
+        # 컨텍스트에 RAG 결과 통합
+        if enable_context_integration:
+            try:
+                # RAG 검색 결과를 컨텍스트에 추가
+                rag_summary = f"RAG 검색 결과: {query}에 대한 {rag_result.get('search_results', 0)}개 관련 문서 발견"
+                
+                # 컨텍스트에 시스템 메시지로 추가
+                context_manager.add_system_message(
+                    rag_summary,
+                    metadata={"session_id": session_id, "type": "rag_integration", "query": query}
+                )
+                
+                logger.info(f"🔄 RAG 결과를 컨텍스트에 통합 완료 (세션: {session_id})")
+                
+            except Exception as e:
+                logger.warning(f"⚠️ 컨텍스트 통합 실패: {e}")
+        
+        # 통합된 결과 반환
+        result = {
+            "status": "success",
+            "rag_response": rag_result,
+            "context_integration": enable_context_integration,
+            "session_id": session_id,
+            "context_summary": context_manager.get_context_summary(session_id) if enable_context_integration else None
+        }
+        
+        logger.info(f"✅ RAG + 컨텍스트 통합 쿼리 완료")
+        return result
+        
+    except Exception as e:
+        logger.error(f"❌ RAG + 컨텍스트 통합 쿼리 실패: {e}")
+        return {"status": "error", "message": str(e)}
+
+@router.get("/rag/context-integrated/summary/{session_id}")
+async def get_rag_context_summary(session_id: str):
+    """RAG 통합 컨텍스트 요약 조회"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                return {"status": "error", "message": "컨텍스트 관리자를 사용할 수 없습니다."}
+        except ImportError:
+            return {"status": "error", "message": "Context manager not available"}
+        
+        # 컨텍스트 요약 정보
+        context_summary = context_manager.get_context_summary(session_id)
+        
+        # RAG 관련 정보 추출
+        rag_contexts = []
+        if session_id in context_manager.session_conversations:
+            for turn in context_manager.session_conversations[session_id]:
+                if (hasattr(turn, 'metadata') and turn.metadata and 
+                    turn.metadata.get('type') == 'rag_integration'):
+                    rag_contexts.append({
+                        "query": turn.metadata.get('query', ''),
+                        "content": turn.content,
+                        "timestamp": turn.timestamp
+                    })
+        
+        return {
+            "status": "success",
+            "session_id": session_id,
+            "context_summary": context_summary,
+            "rag_contexts": rag_contexts,
+            "rag_context_count": len(rag_contexts)
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ RAG 컨텍스트 요약 조회 실패: {e}")
+        return {"status": "error", "message": str(e)}
+
+@router.post("/rag/context-integrated/clear/{session_id}")
+async def clear_rag_context(session_id: str):
+    """RAG 통합 컨텍스트 정리"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                return {"status": "error", "message": "컨텍스트 관리자를 사용할 수 없습니다."}
+        except ImportError:
+            return {"status": "error", "message": "Context manager not available"}
+        
+        # RAG 관련 컨텍스트만 제거
+        if session_id in context_manager.session_conversations:
+            conversation_history = context_manager.session_conversations[session_id]
+            rag_turns = []
+            
+            for turn in conversation_history:
+                if (hasattr(turn, 'metadata') and turn.metadata and 
+                    turn.metadata.get('type') == 'rag_integration'):
+                    rag_turns.append(turn)
+            
+            # RAG 관련 턴 제거
+            for turn in rag_turns:
+                context_manager.remove_message(turn.message_id, session_id)
+            
+            logger.info(f"🗑️ RAG 컨텍스트 정리 완료: {len(rag_turns)}개 턴 제거 (세션: {session_id})")
+            
+            return {
+                "status": "success",
+                "session_id": session_id,
+                "removed_rag_turns": len(rag_turns),
+                "message": f"RAG 컨텍스트 {len(rag_turns)}개 턴이 제거되었습니다."
+            }
+        
+        return {
+            "status": "success",
+            "session_id": session_id,
+            "removed_rag_turns": 0,
+            "message": "제거할 RAG 컨텍스트가 없습니다."
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ RAG 컨텍스트 정리 실패: {e}")
+        return {"status": "error", "message": str(e)}
+
+@router.get("/rag/performance/stats")
+async def get_rag_performance_stats():
+    """RAG 시스템 성능 통계 조회"""
+    try:
+        # RAG 프로세서 성능 통계
+        try:
+            from lily_llm_core.rag_processor import rag_processor
+            rag_stats = rag_processor.get_performance_stats()
+        except ImportError:
+            rag_stats = {"total_requests": 0, "success_rate": 0.0, "avg_processing_time": 0.0}
+        
+        # 벡터 스토어 성능 통계
+        try:
+            from lily_llm_core.vector_store_manager import vector_store_manager
+            vector_stats = vector_store_manager.get_performance_stats()
+        except ImportError:
+            vector_stats = {"total_operations": 0, "success_rate": 0.0, "avg_operation_time": 0.0}
+        
+        # 통합 성능 통계
+        combined_stats = {
+            "rag_processor": rag_stats,
+            "vector_store": vector_stats,
+            "overall": {
+                "total_operations": rag_stats.get("total_requests", 0) + vector_stats.get("total_operations", 0),
+                "success_rate": (rag_stats.get("success_rate", 0.0) + vector_stats.get("success_rate", 0.0)) / 2,
+                "avg_processing_time": (rag_stats.get("avg_processing_time", 0.0) + vector_stats.get("avg_operation_time", 0.0)) / 2
+            },
+            "timestamp": time.time()
+        }
+        
+        return {
+            "status": "success",
+            "performance_stats": combined_stats
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ RAG 성능 통계 조회 실패: {e}")
+        return {"status": "error", "message": str(e)}
+
+@router.post("/rag/performance/reset")
+async def reset_rag_performance_stats():
+    """RAG 시스템 성능 통계 초기화"""
+    try:
+        # RAG 프로세서 통계 초기화
+        try:
+            from lily_llm_core.rag_processor import rag_processor
+            rag_processor.reset_stats()
+        except ImportError:
+            pass
+        
+        # 벡터 스토어 통계 초기화
+        try:
+            from lily_llm_core.vector_store_manager import vector_store_manager
+            vector_store_manager.reset_stats()
+        except ImportError:
+            pass
+        
+        logger.info("���� RAG 시스템 성능 통계 초기화 완료")
+        
+        return {
+            "status": "success",
+            "message": "RAG 시스템 성능 통계가 초기화되었습니다."
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ RAG 성능 통계 초기화 실패: {e}")
+        return {"status": "error", "message": str(e)}
+
+@router.get("/rag/health/check")
+async def rag_health_check():
+    """RAG 시스템 건강 상태 확인"""
+    try:
+        # RAG 프로세서 상태
+        try:
+            from lily_llm_core.rag_processor import rag_processor
+            rag_status = {
+                "rag_processor": "healthy",
+                "enable_context_integration": getattr(rag_processor, 'enable_context_integration', False),
+                "max_context_length": getattr(rag_processor, 'max_context_length', 0),
+                "max_search_results": getattr(rag_processor, 'max_search_results', 0)
+            }
+        except ImportError:
+            rag_status = {"rag_processor": "not_available"}
+        
+        # 벡터 스토어 상태
+        try:
+            from lily_llm_core.vector_store_manager import vector_store_manager
+            vector_status = vector_store_manager.health_check()
+        except ImportError:
+            vector_status = {"status": "not_available"}
+        
+        # 문서 프로세서 상태
+        try:
+            from lily_llm_core.document_processor import document_processor
+            doc_processor_status = {
+                "status": "healthy",
+                "supported_formats": getattr(document_processor, 'supported_formats', []),
+                "ocr_available": hasattr(document_processor, 'ocr_reader') and document_processor.ocr_reader is not None
+            }
+        except ImportError:
+            doc_processor_status = {"status": "not_available"}
+        
+        # 통합 상태
+        overall_status = "healthy"
+        if vector_status.get("status") != "healthy":
+            overall_status = "degraded"
+        
+        return {
+            "status": "success",
+            "overall_status": overall_status,
+            "rag_processor": rag_status,
+            "vector_store": vector_status,
+            "document_processor": doc_processor_status,
+            "timestamp": time.time()
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ RAG 시스템 건강 상태 확인 실패: {e}")
+        return {
+            "status": "error",
+            "overall_status": "unhealthy",
+            "error": str(e),
+            "timestamp": time.time()
+        }
+
+@router.post("/rag/context-integrated/batch-process")
+async def batch_process_with_context_integration(
+    user_id: str = Form(...),
+    session_id: str = Form(...),
+    documents: List[UploadFile] = File(...),
+    enable_context_integration: bool = Form(True)
+):
+    """배치 문서 처리 + 컨텍스트 통합"""
+    try:
+        logger.info(f"📚 배치 문서 처리 + 컨텍스트 통합 시작: 사용자 {user_id}, 세션 {session_id}, 문서 {len(documents)}개")
+        
+        results = []
+        
+        for i, doc in enumerate(documents):
+            try:
+                # 임시 파일로 저장
+                temp_path = f"./temp_{user_id}_{session_id}_{i}_{int(time.time())}"
+                with open(temp_path, "wb") as f:
+                    f.write(doc.file.read())
+                
+                # 문서 ID 생성
+                document_id = f"batch_{session_id}_{i}_{int(time.time())}"
+                
+                # RAG 처리
+                try:
+                    from lily_llm_core.rag_processor import rag_processor
+                    rag_result = rag_processor.process_and_store_document(
+                        user_id=user_id,
+                        document_id=document_id,
+                        file_path=temp_path
+                    )
+                except ImportError:
+                    rag_result = {"success": False, "error": "RAG processor not available"}
+                
+                # 컨텍스트 통합
+                if enable_context_integration and rag_result["success"]:
+                    try:
+                        from lily_llm_core.context_manager import context_manager
+                        context_manager.add_system_message(
+                            f"배치 문서 처리 완료: {doc.filename} ({rag_result.get('chunks', 0)}개 청크)",
+                            metadata={"session_id": session_id, "type": "batch_rag", "filename": doc.filename}
+                        )
+                    except Exception as e:
+                        logger.warning(f"⚠️ 컨텍스트 통합 실패: {e}")
+                
+                # 임시 파일 정리
+                try:
+                    import os
+                    os.remove(temp_path)
+                except:
+                    pass
+                
+                results.append({
+                    "filename": doc.filename,
+                    "document_id": document_id,
+                    "rag_result": rag_result,
+                    "context_integration": enable_context_integration
+                })
+                
+            except Exception as e:
+                logger.error(f"❌ 문서 {doc.filename} 처리 실패: {e}")
+                results.append({
+                    "filename": doc.filename,
+                    "error": str(e),
+                    "context_integration": enable_context_integration
+                })
+        
+        # 성공/실패 통계
+        success_count = sum(1 for r in results if r.get("rag_result", {}).get("success", False))
+        error_count = len(results) - success_count
+        
+        logger.info(f"✅ 배치 문서 처리 완료: {success_count}개 성공, {error_count}개 실패")
+        
+        return {
+            "status": "success",
+            "user_id": user_id,
+            "session_id": session_id,
+            "total_documents": len(documents),
+            "success_count": success_count,
+            "error_count": error_count,
+            "results": results,
+            "context_integration": enable_context_integration
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ 배치 문서 처리 + 컨텍스트 통합 실패: {e}")
+        return {"status": "error", "message": str(e)}
+
+@router.get("/rag/context-integrated/search-history/{session_id}")
+async def get_rag_search_history(session_id: str, limit: int = 10):
+    """RAG 검색 히스토리 조회"""
+    try:
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if not context_manager:
+                return {"status": "error", "message": "컨텍스트 관리자를 사용할 수 없습니다."}
+        except ImportError:
+            return {"status": "error", "message": "Context manager not available"}
+        
+        # RAG 관련 검색 히스토리 추출
+        search_history = []
+        if session_id in context_manager.session_conversations:
+            for turn in context_manager.session_conversations[session_id]:
+                if (hasattr(turn, 'metadata') and turn.metadata and 
+                    turn.metadata.get('type') in ['rag_integration', 'rag_context', 'batch_rag']):
+                    search_history.append({
+                        "timestamp": turn.timestamp,
+                        "type": turn.metadata.get('type'),
+                        "query": turn.metadata.get('query', ''),
+                        "filename": turn.metadata.get('filename', ''),
+                        "content": turn.content
+                    })
+        
+        # 최근 순으로 정렬하고 제한
+        search_history.sort(key=lambda x: x['timestamp'], reverse=True)
+        limited_history = search_history[:limit]
+        
+        return {
+            "status": "success",
+            "session_id": session_id,
+            "search_history": limited_history,
+            "total_count": len(search_history),
+            "limited_count": len(limited_history)
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ RAG 검색 히스토리 조회 실패: {e}")
+        return {"status": "error", "message": str(e)}

lily_llm_api/api/routers/ocr_router.py

@@ -0,0 +1,404 @@
+"""
+OCR (Image OCR, LaTeX-OCR) router for Lily LLM API
+"""
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from typing import Optional
+import logging
+import time
+import os
+import uuid
+
+from ...models.schemas import DocumentUploadResponse, RAGResponse
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+# ============================================================================
+# 이미지 OCR 전용 API 엔드포인트
+# ============================================================================
+
+@router.post("/image-ocr/upload", response_model=DocumentUploadResponse)
+async def upload_image_document(
+    file: UploadFile = File(...),
+    user_id: str = Form("default_user"),
+    document_id: Optional[str] = Form(None)
+):
+    """이미지 OCR 전용 문서 업로드"""
+    start_time = time.time()
+    
+    try:
+        # 문서 ID 생성 (제공되지 않은 경우)
+        if not document_id:
+            document_id = str(uuid.uuid4())[:8]
+        
+        # 임시 파일 저장
+        temp_file_path = f"./temp_image_{document_id}_{file.filename}"
+        with open(temp_file_path, "wb") as f:
+            content = await file.read()
+            f.write(content)
+        
+        # 이미지 OCR 처리 및 벡터 스토어에 저장
+        try:
+            from lily_llm_core.image_rag_processor import image_rag_processor
+            result = image_rag_processor.process_and_store_image_document(
+                user_id, document_id, temp_file_path
+            )
+        except ImportError:
+            result = {
+                "success": False,
+                "error": "Image RAG processor not available"
+            }
+        
+        # 임시 파일 삭제
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+        
+        processing_time = time.time() - start_time
+        logger.info(f"🖼️ 이미지 OCR 문서 업로드 완료 ({processing_time:.2f}초): {file.filename}")
+        
+        return DocumentUploadResponse(
+            success=result["success"],
+            document_id=document_id,
+            message=result.get("message", ""),
+            chunks=result.get("chunks"),
+            latex_count=result.get("latex_count"),
+            error=result.get("error"),
+            auto_response=result.get("auto_response", "")
+        )
+        
+    except Exception as e:
+        logger.error(f"❌ 이미지 OCR 문서 업로드 실패: {e}")
+        return DocumentUploadResponse(
+            success=False,
+            document_id=document_id if 'document_id' in locals() else "unknown",
+            message="이미지 OCR 문서 업로드 중 오류가 발생했습니다.",
+            error=str(e)
+        )
+
+@router.post("/image-ocr/generate", response_model=RAGResponse)
+async def generate_image_ocr_response(
+    query: str = Form(...),
+    user_id: str = Form("default_user"),
+    document_id: str = Form(...)
+):
+    """이미지 OCR 기반 RAG 응답 생성"""
+    start_time = time.time()
+    
+    try:
+        # 이미지 OCR RAG 응답 생성
+        try:
+            from lily_llm_core.image_rag_processor import image_rag_processor
+            result = image_rag_processor.generate_image_rag_response(
+                user_id, document_id, query
+            )
+        except ImportError:
+            result = {
+                "success": False,
+                "response": "Image RAG processor not available",
+                "context": "",
+                "sources": [],
+                "search_results": 0
+            }
+        
+        processing_time = time.time() - start_time
+        result["processing_time"] = processing_time
+        
+        logger.info(f"🖼️ 이미지 OCR RAG 응답 생성 완료 ({processing_time:.2f}초)")
+        return result
+        
+    except Exception as e:
+        logger.error(f"❌ 이미지 OCR RAG 응답 생성 실패: {e}")
+        return RAGResponse(
+            success=False,
+            response=f"이미지 OCR RAG 응답 생성 중 오류가 발생했습니다: {str(e)}",
+            context="",
+            sources=[],
+            search_results=0,
+            processing_time=time.time() - start_time
+        )
+
+@router.get("/image-ocr/document/{user_id}/{document_id}")
+async def get_image_document_info(user_id: str, document_id: str):
+    """이미지 OCR 문서 정보 조회"""
+    try:
+        try:
+            from lily_llm_core.image_rag_processor import image_rag_processor
+            result = image_rag_processor.get_image_document_info(user_id, document_id)
+        except ImportError:
+            result = {
+                "success": False,
+                "error": "Image RAG processor not available"
+            }
+        return result
+    except Exception as e:
+        logger.error(f"❌ 이미지 OCR 문서 정보 조회 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@router.delete("/image-ocr/document/{user_id}/{document_id}")
+async def delete_image_document(user_id: str, document_id: str):
+    """이미지 OCR 문서 삭제"""
+    try:
+        # 벡터 스토어에서 문서 삭제
+        try:
+            from lily_llm_core.vector_store_manager import vector_store_manager
+            success = vector_store_manager.delete_document(user_id, document_id)
+        except ImportError:
+            success = False
+        
+        if success:
+            return {
+                "success": True,
+                "message": "이미지 OCR 문서가 삭제되었습니다."
+            }
+        else:
+            return {
+                "success": False,
+                "error": "이미지 OCR 문서 삭제에 실패했습니다."
+            }
+    except Exception as e:
+        logger.error(f"❌ 이미지 OCR 문서 삭제 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+# ============================================================================
+# LaTeX-OCR 전용 API 엔드포인트
+# ============================================================================
+
+@router.post("/latex-ocr/upload", response_model=DocumentUploadResponse)
+async def upload_latex_document(
+    file: UploadFile = File(...),
+    user_id: str = Form("default_user"),
+    document_id: Optional[str] = Form(None)
+):
+    """LaTeX-OCR 전용 문서 업로드"""
+    start_time = time.time()
+    
+    try:
+        # 문서 ID 생성 (제공되지 않은 경우)
+        if not document_id:
+            document_id = str(uuid.uuid4())[:8]
+        
+        # 임시 파일 저장
+        temp_file_path = f"./temp_latex_{document_id}_{file.filename}"
+        with open(temp_file_path, "wb") as f:
+            content = await file.read()
+            f.write(content)
+        
+        # LaTeX-OCR 처리 및 벡터 스토어에 저장
+        try:
+            from lily_llm_core.latex_rag_processor import latex_rag_processor
+            result = latex_rag_processor.process_and_store_latex_document(
+                user_id, document_id, temp_file_path
+            )
+        except ImportError:
+            result = {
+                "success": False,
+                "error": "LaTeX RAG processor not available"
+            }
+        
+        # 임시 파일 삭제
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+        
+        processing_time = time.time() - start_time
+        logger.info(f"🧮 LaTeX-OCR 문서 업로드 완료 ({processing_time:.2f}초): {file.filename}")
+        
+        return DocumentUploadResponse(
+            success=result["success"],
+            document_id=document_id,
+            message=result.get("message", ""),
+            chunks=result.get("chunks"),
+            latex_count=result.get("latex_count"),
+            error=result.get("error"),
+            auto_response=result.get("auto_response", "")
+        )
+        
+    except Exception as e:
+        logger.error(f"❌ LaTeX-OCR 문서 업로드 실패: {e}")
+        return DocumentUploadResponse(
+            success=False,
+            document_id=document_id if 'document_id' in locals() else "unknown",
+            message="LaTeX-OCR 문서 업로드 중 오류가 발생했습니다.",
+            error=str(e)
+        )
+
+@router.post("/latex-ocr/generate", response_model=RAGResponse)
+async def generate_latex_ocr_response(
+    query: str = Form(...),
+    user_id: str = Form("default_user"),
+    document_id: str = Form(...)
+):
+    """LaTeX-OCR 기반 RAG 응답 생성"""
+    start_time = time.time()
+    
+    try:
+        # LaTeX-OCR RAG 응답 생성
+        try:
+            from lily_llm_core.latex_rag_processor import latex_rag_processor
+            result = latex_rag_processor.generate_latex_rag_response(
+                user_id, document_id, query
+            )
+        except ImportError:
+            result = {
+                "success": False,
+                "response": "LaTeX RAG processor not available",
+                "context": "",
+                "sources": [],
+                "search_results": 0
+            }
+        
+        processing_time = time.time() - start_time
+        result["processing_time"] = processing_time
+        
+        logger.info(f"🧮 LaTeX-OCR RAG 응답 생성 완료 ({processing_time:.2f}초)")
+        return result
+        
+    except Exception as e:
+        logger.error(f"❌ LaTeX-OCR RAG 응답 생성 실패: {e}")
+        return RAGResponse(
+            success=False,
+            response=f"LaTeX-OCR RAG 응답 생성 중 오류가 발생했습니다: {str(e)}",
+            context="",
+            sources=[],
+            search_results=0,
+            processing_time=time.time() - start_time
+        )
+
+@router.get("/latex-ocr/document/{user_id}/{document_id}")
+async def get_latex_document_info(user_id: str, document_id: str):
+    """LaTeX-OCR 문서 정보 조회"""
+    try:
+        try:
+            from lily_llm_core.latex_rag_processor import latex_rag_processor
+            result = latex_rag_processor.get_latex_document_info(user_id, document_id)
+        except ImportError:
+            result = {
+                "success": False,
+                "error": "LaTeX RAG processor not available"
+            }
+        return result
+    except Exception as e:
+        logger.error(f"❌ LaTeX-OCR 문서 정보 조회 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@router.delete("/latex-ocr/document/{user_id}/{document_id}")
+async def delete_latex_document(user_id: str, document_id: str):
+    """LaTeX-OCR 문서 삭제"""
+    try:
+        # 벡터 스토어에서 문서 삭제
+        try:
+            from lily_llm_core.vector_store_manager import vector_store_manager
+            success = vector_store_manager.delete_document(user_id, document_id)
+        except ImportError:
+            success = False
+        
+        if success:
+            return {
+                "success": True,
+                "message": "LaTeX-OCR 문서가 삭제되었습니다."
+            }
+        else:
+            return {
+                "success": False,
+                "error": "LaTeX-OCR 문서 삭제에 실패했습니다."
+            }
+    except Exception as e:
+        logger.error(f"❌ LaTeX-OCR 문서 삭제 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+# ============================================================================
+# LaTeX-OCR + FAISS 통합 시스템 엔드포인트 (현재 비활성화)
+# ============================================================================
+
+@router.post("/latex-ocr-faiss/process", response_model=DocumentUploadResponse)
+async def process_pdf_with_latex_faiss(
+    file: UploadFile = File(...),
+    user_id: str = Form("default_user"),
+    system_type: str = Form("simple")  # "simple" 또는 "integrated"
+):
+    """PDF에서 LaTeX 수식 추출 및 FAISS 저장 (현재 비활성화)"""
+    try:
+        # 파일 저장
+        from pathlib import Path
+        upload_dir = Path("uploads/latex_ocr_faiss")
+        upload_dir.mkdir(parents=True, exist_ok=True)
+        
+        file_path = upload_dir / f"{user_id}_{file.filename}"
+        with open(file_path, "wb") as f:
+            content = await file.read()
+            f.write(content)
+        
+        # 현재 비활성화된 기능
+        return DocumentUploadResponse(
+            success=False,
+            document_id="",
+            message="LaTeX-OCR + FAISS 기능이 현재 비활성화되어 있습니다",
+            error="삭제된 모듈로 인해 기능이 비활성화됨"
+        )
+        
+    except Exception as e:
+        logger.error(f"LaTeX-OCR + FAISS 처리 오류: {e}")
+        return DocumentUploadResponse(
+            success=False,
+            document_id="",
+            message="처리 중 오류가 발생했습니다",
+            error=f"처리 중 오류가 발생했습니다: {str(e)}"
+        )
+
+@router.post("/latex-ocr-faiss/search", response_model=RAGResponse)
+async def search_latex_formulas(
+    query: str = Form(...),
+    user_id: str = Form("default_user"),
+    document_path: Optional[str] = Form(None),
+    system_type: str = Form("simple"),
+    k: int = Form(5)
+):
+    """저장된 LaTeX 수식 검색 (현재 비활성화)"""
+    try:
+        # 현재 비활성화된 기능
+        return RAGResponse(
+            success=False,
+            response="LaTeX-OCR + FAISS 검색 기능이 현재 비활성화되어 있습니다",
+            context="",
+            sources=[],
+            search_results=0,
+            processing_time=0.0,
+            error="삭제된 모듈로 인해 기능이 비활성화됨"
+        )
+        
+    except Exception as e:
+        logger.error(f"LaTeX 수식 검색 오류: {e}")
+        return RAGResponse(
+            success=False,
+            response="검색 중 오류가 발생했습니다.",
+            context="",
+            sources=[],
+            search_results=0,
+            processing_time=0.0,
+            error=str(e)
+        )
+
+@router.get("/latex-ocr-faiss/status")
+async def get_latex_ocr_faiss_status():
+    """LaTeX-OCR + FAISS 시스템 상태 확인 (현재 비활성화)"""
+    try:
+        return {
+            "simple_system_initialized": False,
+            "integrated_system_initialized": False,
+            "status": "disabled",
+            "message": "LaTeX-OCR + FAISS 기능이 현재 비활성화되어 있습니다"
+        }
+    except Exception as e:
+        logger.error(f"상태 확인 오류: {e}")
+        return {"status": "error", "error": str(e)}

lily_llm_api/api/routers/user_memory_router.py

@@ -0,0 +1,341 @@
+"""
+User memory settings management router for Lily LLM API
+"""
+from fastapi import APIRouter, HTTPException, Form
+import logging
+import time
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+# ============================================================================
+# 사용자 메모리 설정 관리 API
+# ============================================================================
+
+@router.get("/user/memory/settings/{user_id}")
+async def get_user_memory_settings(user_id: str):
+    """사용자 메모리 설정 조회"""
+    try:
+        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 ImportError:
+            return {"status": "error", "message": "User memory manager not available"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@router.post("/user/memory/settings/{user_id}")
+async def update_user_memory_settings(
+    user_id: str,
+    keep_memory_on_room_change: bool = Form(True)
+):
+    """사용자 메모리 설정 업데이트"""
+    try:
+        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 ImportError:
+            return {"status": "error", "message": "User memory manager not available"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@router.post("/user/memory/room-change/{user_id}")
+async def handle_room_change(user_id: str, new_room_id: str = Form(...)):
+    """Room 변경 시 메모리 처리"""
+    try:
+        try:
+            from lily_llm_core.user_memory_manager import user_memory_manager
+            from lily_llm_core.integrated_memory_manager import integrated_memory_manager
+        except ImportError:
+            return {"status": "error", "message": "Memory managers not available"}
+        
+        # 사용자 설정 확인
+        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}로 이동 - 메모리 초기화")
+            
+            # 세션 컨텍스트 초기화
+            try:
+                from lily_llm_core.context_manager import context_manager
+                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}")
+            except ImportError:
+                logger.warning("⚠️ Context manager not available for session cleanup")
+            
+            # 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)}
+
+@router.get("/user/memory/status/{user_id}")
+async def get_user_memory_status(user_id: str):
+    """사용자 메모리 상태 조회"""
+    try:
+        try:
+            from lily_llm_core.user_memory_manager import user_memory_manager
+            from lily_llm_core.integrated_memory_manager import integrated_memory_manager
+            
+            # 사용자 메모리 설정
+            memory_settings = {
+                "keep_memory_on_room_change": user_memory_manager.get_memory_setting(user_id, "keep_memory_on_room_change")
+            }
+            
+            # 사용자 관련 세션 정보
+            session_info = {}
+            try:
+                from lily_llm_core.context_manager import context_manager
+                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:
+                        session_info[session_id] = {
+                            "turns": len(context_manager.session_conversations[session_id]),
+                            "context_summary": context_manager.get_context_summary(session_id)
+                        }
+            except ImportError:
+                pass
+            
+            # 사용자 관련 문서 정보
+            document_info = {}
+            try:
+                # 사용자가 업로드한 문서들 조회
+                user_documents = integrated_memory_manager.get_user_documents(user_id)
+                document_info = {
+                    "total_documents": len(user_documents),
+                    "document_types": list(set(doc.get('type', 'unknown') for doc in user_documents if isinstance(doc, dict))),
+                    "recent_uploads": sorted(user_documents, key=lambda x: x.get('upload_time', 0), reverse=True)[:5] if user_documents else []
+                }
+            except Exception as e:
+                logger.warning(f"⚠️ 사용자 문서 정보 조회 실패: {e}")
+            
+            return {
+                "status": "success",
+                "user_id": user_id,
+                "memory_settings": memory_settings,
+                "session_info": session_info,
+                "document_info": document_info,
+                "timestamp": time.time()
+            }
+            
+        except ImportError:
+            return {"status": "error", "message": "Memory managers not available"}
+            
+    except Exception as e:
+        logger.error(f"❌ 사용자 메모리 상태 조회 실패: {e}")
+        return {"status": "error", "message": str(e)}
+
+@router.post("/user/memory/clear/{user_id}")
+async def clear_user_memory(user_id: str, clear_type: str = Form("all")):
+    """사용자 메모리 정리"""
+    try:
+        try:
+            from lily_llm_core.user_memory_manager import user_memory_manager
+            from lily_llm_core.integrated_memory_manager import integrated_memory_manager
+        except ImportError:
+            return {"status": "error", "message": "Memory managers not available"}
+        
+        cleared_items = {}
+        
+        if clear_type in ["all", "sessions"]:
+            # 세션 컨텍스트 정리
+            try:
+                from lily_llm_core.context_manager import context_manager
+                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)
+                    
+                    cleared_items["sessions"] = len(user_sessions)
+                    logger.info(f"🗑️ 사용자 {user_id} 세션 컨텍스트 {len(user_sessions)}개 정리 완료")
+            except ImportError:
+                pass
+        
+        if clear_type in ["all", "documents"]:
+            # 사용자 문서 정리
+            try:
+                user_documents = integrated_memory_manager.get_user_documents(user_id)
+                for doc in user_documents:
+                    if isinstance(doc, dict) and doc.get('document_id'):
+                        integrated_memory_manager.remove_document(doc['document_id'])
+                
+                cleared_items["documents"] = len(user_documents)
+                logger.info(f"🗑️ 사용자 {user_id} 문서 {len(user_documents)}개 정리 완료")
+            except Exception as e:
+                logger.warning(f"⚠️ 사용자 문서 정리 실패: {e}")
+        
+        if clear_type in ["all", "settings"]:
+            # 메모리 설정 초기화
+            try:
+                user_memory_manager.reset_user_settings(user_id)
+                cleared_items["settings"] = True
+                logger.info(f"🔄 사용자 {user_id} 메모리 설정 초기화 완료")
+            except Exception as e:
+                logger.warning(f"⚠️ 메모리 설정 초기화 실패: {e}")
+        
+        return {
+            "status": "success",
+            "message": f"사용자 {user_id} 메모리 정리 완료",
+            "user_id": user_id,
+            "clear_type": clear_type,
+            "cleared_items": cleared_items
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ 사용자 메모리 정리 실패: {e}")
+        return {"status": "error", "message": str(e)}
+
+@router.get("/user/memory/analytics/{user_id}")
+async def get_user_memory_analytics(user_id: str):
+    """사용자 메모리 사용량 분석"""
+    try:
+        try:
+            from lily_llm_core.user_memory_manager import user_memory_manager
+            from lily_llm_core.integrated_memory_manager import integrated_memory_manager
+        except ImportError:
+            return {"status": "error", "message": "Memory managers not available"}
+        
+        analytics = {
+            "user_id": user_id,
+            "timestamp": time.time(),
+            "memory_usage": {},
+            "session_stats": {},
+            "document_stats": {}
+        }
+        
+        # 세션 통계
+        try:
+            from lily_llm_core.context_manager import context_manager
+            if context_manager:
+                user_sessions = [
+                    session_id for session_id in context_manager.session_conversations.keys()
+                    if f"user_{user_id}" in session_id
+                ]
+                
+                total_turns = sum(len(context_manager.session_conversations[session_id]) for session_id in user_sessions)
+                total_tokens = sum(
+                    context_manager._estimate_tokens(
+                        context_manager.get_context(include_system=False, session_id=session_id)
+                    ) for session_id in user_sessions
+                )
+                
+                analytics["session_stats"] = {
+                    "total_sessions": len(user_sessions),
+                    "total_turns": total_turns,
+                    "total_tokens": total_tokens,
+                    "avg_turns_per_session": total_turns / len(user_sessions) if user_sessions else 0
+                }
+        except ImportError:
+            pass
+        
+        # 문서 통계
+        try:
+            user_documents = integrated_memory_manager.get_user_documents(user_id)
+            document_types = {}
+            total_size = 0
+            
+            for doc in user_documents:
+                if isinstance(doc, dict):
+                    doc_type = doc.get('type', 'unknown')
+                    document_types[doc_type] = document_types.get(doc_type, 0) + 1
+                    total_size += doc.get('size', 0)
+            
+            analytics["document_stats"] = {
+                "total_documents": len(user_documents),
+                "document_types": document_types,
+                "total_size_bytes": total_size,
+                "total_size_mb": total_size / (1024 * 1024)
+            }
+        except Exception as e:
+            logger.warning(f"⚠️ 문서 통계 조회 실패: {e}")
+        
+        # 메모리 사용량 요약
+        analytics["memory_usage"] = {
+            "session_memory_mb": analytics["session_stats"].get("total_tokens", 0) * 4 / (1024 * 1024),  # 토큰당 약 4바이트 추정
+            "document_memory_mb": analytics["document_stats"].get("total_size_mb", 0),
+            "total_memory_mb": (analytics["session_stats"].get("total_tokens", 0) * 4 / (1024 * 1024)) + analytics["document_stats"].get("total_size_mb", 0)
+        }
+        
+        return {
+            "status": "success",
+            "analytics": analytics
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ 사용자 메모리 분석 실패: {e}")
+        return {"status": "error", "message": str(e)}

lily_llm_api/app_v2_modular.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+Lily LLM API 서버 v2 - 모듈화된 버전
+"""
+import uvicorn
+import logging
+import warnings
+
+# 🔄 RoPE 경고 숨기기
+warnings.filterwarnings("ignore", message="The attention layers in this model are transitioning")
+warnings.filterwarnings("ignore", message="rotary_pos_emb will be removed")
+warnings.filterwarnings("ignore", message="position_embeddings will be mandatory")
+
+# logging 설정
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+from .core.app_factory import create_app
+
+# FastAPI 애플리케이션 생성
+app = create_app()
+
+def run_server():
+    """서버 실행"""
+    uvicorn.run(
+        "app_v2_modular:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=False,
+        workers=1
+    )
+
+if __name__ == "__main__":
+    run_server()

lily_llm_api/core/__init__.py

@@ -0,0 +1,3 @@
+"""
+Core package for Lily LLM API
+"""

lily_llm_api/core/app_factory.py

@@ -0,0 +1,125 @@
+"""
+FastAPI app factory for Lily LLM API
+"""
+import logging
+import warnings
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+logger = logging.getLogger(__name__)
+
+# 🔄 RoPE 경고 숨기기 (Kanana 모델 내부 구현 관련)
+warnings.filterwarnings("ignore", message="The attention layers in this model are transitioning")
+warnings.filterwarnings("ignore", message="rotary_pos_emb will be removed")
+warnings.filterwarnings("ignore", message="position_embeddings will be mandatory")
+
+@asynccontextmanager
+async def create_lifespan_handler(app):
+    """서버 생명주기 관리 핸들러 생성"""
+    # 서버 시작 시
+    logger.info("🚀 서버 시작 이벤트 실행 중...")
+    
+    # CPU 스레드 최적화 적용
+    try:
+        from ..utils.system_utils import configure_cpu_threads, select_model_interactive
+        configure_cpu_threads()
+        logger.info("✅ CPU 스레드 최적화 완료")
+    except Exception as e:
+        logger.error(f"❌ CPU 스레드 설정 실패: {e}")
+    
+    # 🔄 모델 선택 복원: 사용자가 모델을 선택할 수 있도록
+    try:
+        selected_model_id = select_model_interactive()
+        logger.info(f"🚀 서버 시작 시 선택된 모델: {selected_model_id}")
+        
+        from ..services.model_service import load_model_async
+        await load_model_async(selected_model_id)
+        
+        from ..services.model_service import is_model_loaded
+        model_loaded = is_model_loaded()
+        logger.info(f"✅ 서버가 모델로 준비되었습니다.")
+        logger.info(f"✅ model_loaded 상태: {model_loaded}")
+        
+        # 🔄 실무용: 고급 컨텍스트 관리자 설정
+        try:
+            from lily_llm_core.context_manager import context_manager
+            # 요약 방법을 smart로 설정 (가장 균형잡힌 요약)
+            context_manager.set_summary_method("smart")
+            logger.info("✅ 고급 컨텍스트 관리자 설정 완료: smart 요약 방법 활성화")
+            
+            # 자동 정리 설정 최적화
+            context_manager.set_auto_cleanup_config(
+                enabled=True,
+                interval_turns=5,      # 5턴마다 정리
+                interval_time=180,     # 3분마다 정리
+                strategy="aggressive"   # 적극적 정리로 메모리 최적화
+            )
+            logger.info("✅ 자동 정리 설정 최적화 완료")
+            
+        except Exception as e:
+            logger.warning(f"⚠️ 고급 컨텍스트 관리자 설정 실패: {e}")
+            
+    except Exception as e:
+        logger.error(f"❌ 모델 로드에 실패했습니다: {e}", exc_info=True)
+    
+    logger.info("✅ 서버 시작 이벤트 완료")
+    
+    yield  # 서버 실행 중
+    
+    # 서버 종료 시
+    logger.info("🛑 서버 종료 이벤트 실행 중...")
+    
+    # 스레드 풀 실행기 종료
+    try:
+        from ..services.model_service import shutdown_executor
+        shutdown_executor()
+        logger.info("✅ 스레드 풀 실행기 종료 완료")
+    except Exception as e:
+        logger.warning(f"⚠️ 스레드 풀 실행기 종료 실패: {e}")
+    
+    logger.info("✅ 서버 종료 이벤트 완료")
+
+def create_app() -> FastAPI:
+    """FastAPI 앱 생성"""
+    # FastAPI 앱 생성
+    app = FastAPI(
+        title="Lily LLM API v2",
+        description="다중 모델 지원 LLM API 서버",
+        version="2.0.0",
+        lifespan=create_lifespan_handler
+    )
+    
+    # CORS 설정
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[
+            "http://localhost:8001",
+            "http://127.0.0.1:8001",
+            "http://localhost:3000",
+            "http://127.0.0.1:3000",
+            "*"  # 개발 중에는 모든 origin 허용
+        ],
+        allow_credentials=True,
+        allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+        allow_headers=["*"],
+    )
+    
+    # 라우터 등록
+    from ..api.routers import (
+        model_router, generation_router, lora_router, context_router, 
+        document_router, ocr_router, advanced_context_router,
+        multimodal_rag_router, user_memory_router
+    )
+    
+    app.include_router(model_router.router, prefix="/api/v2", tags=["models"])
+    app.include_router(generation_router.router, prefix="/api/v2", tags=["generation"])
+    app.include_router(lora_router.router, prefix="/api/v2", tags=["lora"])
+    app.include_router(context_router.router, prefix="/api/v2", tags=["context"])
+    app.include_router(document_router.router, prefix="/api/v2", tags=["document"])
+    app.include_router(ocr_router.router, prefix="/api/v2", tags=["ocr"])
+    app.include_router(advanced_context_router.router, prefix="/api/v2", tags=["advanced-context"])
+    app.include_router(multimodal_rag_router.router, prefix="/api/v2", tags=["multimodal-rag"])
+    app.include_router(user_memory_router.router, prefix="/api/v2", tags=["user-memory"])
+    
+    return app

lily_llm_api/models/back/configuration.py

@@ -1,125 +0,0 @@
-import logging
-
-from transformers.configuration_utils import PretrainedConfig
-from transformers.models.llama.configuration_llama import LlamaConfig
-from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD
-
-logger = logging.getLogger("kanana-1.5-v")
-
-
-class KananaVVisionConfig(PretrainedConfig):
-    model_type = "kanana-1.5-v-visual-encoder"
-    base_config_key = "vision_config"
-
-    def __init__(
-        self,
-        depth=32,
-        embed_dim=1280,
-        mlp_ratio=4,
-        num_heads=16,
-        in_chans=3,
-        hidden_size=1280,
-        patch_size=14,
-        spatial_merge_size=2,
-        spatial_patch_size=14,
-        temporal_patch_size=2,
-        initializer_range=0.02,
-        image_size="dynamic",
-        image_mean=OPENAI_CLIP_MEAN,
-        image_std=OPENAI_CLIP_STD,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-
-        self.depth = depth
-        self.embed_dim = embed_dim
-        self.mlp_ratio = mlp_ratio
-        self.num_heads = num_heads
-        self.in_chans = in_chans
-        self.hidden_size = hidden_size
-        self.patch_size = patch_size
-        self.spatial_merge_size = spatial_merge_size
-        self.spatial_patch_size = spatial_patch_size
-        self.temporal_patch_size = temporal_patch_size
-        self.initializer_range = initializer_range
-        self.image_size = image_size
-        self.image_mean = image_mean
-        self.image_std = image_std
-
-
-class KananaVVisualProjectorConfig(PretrainedConfig):
-    model_type = "kanana-1.5-v-visual_projector"
-    base_config_key = "projector_config"
-
-    def __init__(
-        self,
-        depth=2,
-        encoder_hidden_size=1280,
-        feature_layer_index=-1,
-        hidden_size=1024,
-        merge_size=2,
-        mlp_depth=2,
-        num_eos_tokens=0,
-        output_hidden_size=2048,
-        pos_emb=True,
-        pos_emb_size=576,
-        prenorm=False,
-        projector_type="dynamic-c-abs",
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-
-        self.depth = depth
-        self.encoder_hidden_size = encoder_hidden_size
-        self.feature_layer_index = feature_layer_index
-        self.hidden_size = hidden_size
-        self.merge_size = merge_size
-        self.mlp_depth = mlp_depth
-        self.num_eos_tokens = num_eos_tokens
-        self.output_hidden_size = output_hidden_size
-        self.pos_emb = pos_emb
-        self.pos_emb_size = pos_emb_size
-        self.prenorm = prenorm
-        self.projector_type = projector_type
-
-
-class KananaLanguageConfig(LlamaConfig):
-    model_type = "kanana-1.5-3b-instruct"
-    base_config_key = "text_config"
-
-    def __init__(
-        self,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-
-
-class KananaVConfig(PretrainedConfig):
-    model_type = "kanana-1.5-v"
-    is_composition = True
-
-    def __init__(
-        self,
-        vision_config: dict = {},
-        projector_config: dict = {},
-        text_config: dict = {},
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-
-        # Vision config
-        self.vision_config = KananaVVisionConfig(**vision_config)
-
-        # Visual projector config
-        self.projector_config = KananaVVisualProjectorConfig(**projector_config)
-
-        # Language model config
-        self.text_config = KananaLanguageConfig(**text_config)
-
-    @property
-    def num_visual_tokens(self):
-        return "dynamic"
-
-    @property
-    def hidden_size(self):
-        return self.text_config.hidden_size

lily_llm_api/models/back/modeling.py

@@ -1,973 +0,0 @@
-from functools import partial
-import logging
-import re
-from typing import Optional, Tuple, Union, List
-
-from einops import rearrange
-from timm.layers import LayerNorm, LayerNorm2d
-from timm.layers.pos_embed import resample_abs_pos_embed
-from timm.models.regnet import RegStage
-import torch
-from torch import nn
-import torch.nn.functional as F
-import torch.utils.checkpoint
-from transformers import LlamaForCausalLM
-from transformers.modeling_outputs import BaseModelOutput
-from transformers.modeling_utils import PreTrainedModel
-from transformers.models.auto import AutoModelForCausalLM
-from transformers.models.qwen2_vl.configuration_qwen2_vl import (
-    Qwen2VLVisionConfig,
-)
-from transformers.models.qwen2_vl.modeling_qwen2_vl import (
-    PatchEmbed,
-    Qwen2VLPreTrainedModel,
-    Qwen2VisionTransformerPretrainedModel,
-    Qwen2VLVisionBlock,
-    VisionRotaryEmbedding
-)
-
-from configuration import KananaVVisualProjectorConfig, KananaVConfig
-
-logger = logging.getLogger("kanana-1.5-v")
-
-
-def build_pos_embeds(
-    config: KananaVVisualProjectorConfig, num_input_tokens: int, vision_hidden_size: int
-):
-    # pos emb
-    if config.pos_emb:
-        # ✨ 수정: num_input_tokens가 음수일 때 기본값 사용
-        if num_input_tokens <= 0:
-            num_input_tokens = config.pos_emb_size if hasattr(config, 'pos_emb_size') else 576
-        pos_emb = torch.nn.Parameter(torch.zeros(1, num_input_tokens, vision_hidden_size))
-        nn.init.trunc_normal_(pos_emb, mean=0.0, std=0.02)
-    else:
-        pos_emb = None
-
-    return pos_emb
-
-
-def build_eos_tokens(config: KananaVVisualProjectorConfig, output_hidden_size: int):
-    # think tokens
-    num_eos_tokens = config.num_eos_tokens
-    if num_eos_tokens:
-        eos_tokens = torch.nn.Parameter(torch.randn(1, num_eos_tokens, output_hidden_size))
-        nn.init.trunc_normal_(eos_tokens, mean=0.0, std=config.initializer_range)
-    else:
-        eos_tokens = None
-
-    return eos_tokens
-
-
-def build_prenorm(config: KananaVVisualProjectorConfig):
-    if getattr(config, "prenorm", False):
-        prenorm = LayerNorm(config.encoder_hidden_size)
-    else:
-        prenorm = None
-    return prenorm
-
-
-def build_mlp(depth: int, hidden_size: int, output_hidden_size: int):
-    layers = [nn.Linear(hidden_size, output_hidden_size)]
-    for _ in range(1, depth):
-        layers.append(nn.SiLU())
-        layers.append(nn.Linear(output_hidden_size, output_hidden_size))
-    return nn.Sequential(*layers)
-
-
-class PatchMerge(nn.Module):
-    def __init__(self, merge_size):
-        super().__init__()
-        self.merge_size = merge_size
-
-    def forward(self, x, channel_last=False):
-        if channel_last:
-            x = rearrange(x, "B H W D -> B D H W")
-        _, D, H, W = x.shape
-        
-        # 홀수 차원을 처리하기 위해 패딩 추가
-        pad_h = (self.merge_size - H % self.merge_size) % self.merge_size
-        pad_w = (self.merge_size - W % self.merge_size) % self.merge_size
-        
-        if pad_h > 0 or pad_w > 0:
-            print(f"🔍 PatchMerge - 패딩 추가: H={H}->{H+pad_h}, W={W}->{W+pad_w}")
-            x = torch.nn.functional.pad(x, (0, pad_w, 0, pad_h), mode='replicate')
-            H, W = H + pad_h, W + pad_w
-        
-        merged_x = rearrange(
-            x, "B D (H h2) (W w2) -> B (D h2 w2) H W", h2=self.merge_size, w2=self.merge_size
-        )
-        return merged_x
-
-
-class DynamicCAbstractor(nn.Module):
-    """Dynamic C-Abstractor based on RegBlock"""
-
-    def __init__(self, config: KananaVVisualProjectorConfig, num_input_tokens: int):
-        super().__init__()
-        self.config = config
-        
-        # ✨ 수정: num_input_tokens가 음수일 때 기본값 설정
-        if num_input_tokens <= 0:
-            num_input_tokens = config.pos_emb_size if hasattr(config, 'pos_emb_size') else 576
-        self.num_input_tokens = num_input_tokens
-        
-        # ✨ 추가: 누락된 속성들 설정
-        self.merge_size = getattr(config, 'merge_size', 2)
-        self.pos_emb_size = getattr(config, 'pos_emb_size', 576)
-        
-        # ✨ 최적화: 모든 레이어를 bfloat16으로 초기화
-        self.pos_emb = build_pos_embeds(config, num_input_tokens, config.encoder_hidden_size)
-        if self.pos_emb is not None:
-            self.pos_emb.data = self.pos_emb.data.to(torch.bfloat16)
-        
-        self.eos_tokens = build_eos_tokens(config, config.output_hidden_size)
-        if self.eos_tokens is not None:
-            self.eos_tokens.data = self.eos_tokens.data.to(torch.bfloat16)
-        
-        self.prenorm = build_prenorm(config)
-        if self.prenorm is not None:
-            self.prenorm = self.prenorm.to(torch.bfloat16)
-        
-        # ✨ 수정: build_net에서 self.net과 self.readout 설정
-        self.build_net()
-        
-        # ✨ 최적화: net 레이어들을 bfloat16으로 변환
-        if hasattr(self, 'net'):
-            if isinstance(self.net, nn.ModuleList):
-                for layer in self.net:
-                    layer = layer.to(torch.bfloat16)
-                    for module in layer.modules():
-                        if hasattr(module, 'weight'):
-                            module.weight.data = module.weight.data.to(torch.bfloat16)
-                        if hasattr(module, 'bias') and module.bias is not None:
-                            module.bias.data = module.bias.data.to(torch.bfloat16)
-            else:
-                # self.net이 단일 모듈인 경우
-                self.net = self.net.to(torch.bfloat16)
-                for module in self.net.modules():
-                    if hasattr(module, 'weight'):
-                        module.weight.data = module.weight.data.to(torch.bfloat16)
-                    if hasattr(module, 'bias') and module.bias is not None:
-                        module.bias.data = module.bias.data.to(torch.bfloat16)
-        
-        # ✨ 최적화: readout 레이어를 bfloat16으로 변환
-        if hasattr(self, 'readout'):
-            self.readout = self.readout.to(torch.bfloat16)
-            for module in self.readout.modules():
-                if hasattr(module, 'weight'):
-                    module.weight.data = module.weight.data.to(torch.bfloat16)
-                if hasattr(module, 'bias') and module.bias is not None:
-                    module.bias.data = module.bias.data.to(torch.bfloat16)
-
-    def build_net(self):
-        encoder_hidden_size = self.config.encoder_hidden_size
-        hidden_size = self.config.hidden_size
-        output_hidden_size = self.config.output_hidden_size
-        depth = self.config.depth
-        mlp_depth = self.config.mlp_depth
-
-        RegBlock = partial(
-            RegStage,
-            stride=1,
-            dilation=1,
-            act_layer=nn.SiLU,
-            norm_layer=LayerNorm2d,
-        )
-
-        s1 = RegBlock(
-            depth,
-            encoder_hidden_size,
-            hidden_size,
-        )
-        sampler = PatchMerge(merge_size=self.merge_size)
-        s2 = RegBlock(
-            depth,
-            self.merge_size**2 * hidden_size,
-            hidden_size,
-        )
-
-        if depth:
-            self.net = nn.ModuleList([s1, sampler, s2])
-            self.readout = build_mlp(mlp_depth, hidden_size, output_hidden_size)
-        else:
-            self.net = sampler
-            self.readout = build_mlp(mlp_depth, encoder_hidden_size, output_hidden_size)
-
-    def forward(self, flattened_visual_embeds, grid_thw, **unused_kwargs):
-        n_token_loc = torch.prod(grid_thw, dim=1)
-        split_visual_embeds = torch.split(flattened_visual_embeds, n_token_loc.tolist())
-
-        flattened_visual_embeds = []
-        for _visual_embeds, _grid_thw in zip(split_visual_embeds, grid_thw):
-            T, H, W = _grid_thw
-            assert T == 1, "T must be 1. Video is not supported yet."
-            reshaped_visual_embeds = rearrange(
-                _visual_embeds, "(t h w) d -> 1 t h w d", t=T, h=H, w=W
-            )
-            # remove temporal dim
-            reshaped_visual_embeds = reshaped_visual_embeds[:, 0]
-
-            if self.prenorm is not None:
-                reshaped_visual_embeds = self.prenorm(reshaped_visual_embeds)
-
-            if self.pos_emb is not None:
-                # interpolate pos emb and add to visual embeds
-                print(f"🔍 abstractor - pos_emb 형태: {self.pos_emb.shape}")
-                print(f"🔍 abstractor - reshaped_visual_embeds 형태: {reshaped_visual_embeds.shape}")
-                
-                _local_pos_emb = resample_abs_pos_embed(
-                    posemb=self.pos_emb,
-                    old_size=tuple([int(self.pos_emb_size**0.5)] * 2),
-                    new_size=(H, W),
-                    num_prefix_tokens=0,
-                )
-                _local_pos_emb = rearrange(
-                    _local_pos_emb,
-                    "1 (h w) d -> 1 h w d",
-                    h=H,
-                    w=W,
-                )
-                print(f"🔍 abstractor - _local_pos_emb 형태: {_local_pos_emb.shape}")
-                
-                # 차원이 맞지 않는 경우 처리
-                if reshaped_visual_embeds.shape[-1] != _local_pos_emb.shape[-1]:
-                    print(f"🔍 abstractor - 차원 불일치 감지, pos_emb 건너뛰기")
-                    # pos_emb를 건너뛰고 visual_embeds만 사용
-                else:
-                    reshaped_visual_embeds = reshaped_visual_embeds + _local_pos_emb
-
-            reshaped_visual_embeds = self._forward(
-                reshaped_visual_embeds,
-                input_size=(H, W),
-            )
-            flattened_visual_embeds.append(reshaped_visual_embeds)
-        reshaped_visual_embeds = torch.cat(flattened_visual_embeds, dim=0)
-        output = BaseModelOutput(last_hidden_state=reshaped_visual_embeds)
-        return output
-
-    def _forward(self, x, input_size):
-        h, w = input_size
-        
-        x = rearrange(x, "1 h w d -> 1 d h w", h=h, w=w)
-        
-        # 입력 채널 수가 맞지 않는 경우 처리
-        # RegStage의 첫 번째 블록에서 채널 수 확인
-        try:
-            if hasattr(self.net[0], 'conv'):
-                expected_channels = self.net[0].conv.in_channels
-            elif hasattr(self.net[0], 'blocks') and len(self.net[0].blocks) > 0:
-                expected_channels = self.net[0].blocks[0].conv1.in_channels
-            else:
-                # 기본값 사용
-                expected_channels = 1280
-        except:
-            expected_channels = 1280
-        
-        actual_channels = x.shape[1]
-        
-        if actual_channels != expected_channels:
-            # 선형 변환으로 채널 수 조정
-            if not hasattr(self, 'channel_adapter'):
-                # channel_adapter를 bfloat16으로 생성
-                self.channel_adapter = nn.Linear(actual_channels, expected_channels, dtype=torch.bfloat16).to(x.device)
-            
-            x = x.permute(0, 2, 3, 1)  # (1, d, h, w) -> (1, h, w, d)
-            # 입력을 bfloat16으로 변환 (한 번만)
-            if x.dtype != torch.bfloat16:
-                x = x.to(torch.bfloat16)
-            x = self.channel_adapter(x)  # 채널 수 조정
-            x = x.permute(0, 3, 1, 2)  # (1, h, w, d) -> (1, d, h, w)
-        
-        # ✨ 최적화: 이미 bfloat16으로 초기화된 레이어들 사용
-        x = self.net[0](x)
-        x = self.net[1](x)
-        x = self.net[2](x)
-        x = rearrange(x, "1 d h w -> (h w) d")
-        
-        # ✨ 최적화: 이미 bfloat16으로 초기화된 readout 사용
-        x = self.readout(x)
-        
-        return x
-
-
-class CustomQwen2VLVE(Qwen2VisionTransformerPretrainedModel):
-    config_class = Qwen2VLVisionConfig
-    _no_split_modules = ["Qwen2VLVisionBlock"]
-
-    def __init__(self, config) -> None:
-        Qwen2VLPreTrainedModel.__init__(self, config)
-        self.spatial_merge_size = config.spatial_merge_size
-        self.gradient_checkpointing = False
-
-        self.patch_embed = PatchEmbed(
-            patch_size=config.patch_size,
-            temporal_patch_size=config.temporal_patch_size,
-            in_channels=config.in_channels,
-            embed_dim=config.embed_dim,
-        )
-
-        head_dim = config.embed_dim // config.num_heads
-        self.rotary_pos_emb = VisionRotaryEmbedding(head_dim // 2)
-
-        self.blocks = nn.ModuleList(
-            [Qwen2VLVisionBlock(config, config._attn_implementation) for _ in range(config.depth)]
-        )
-
-    def forward(
-        self,
-        pixel_values: torch.Tensor,
-        grid_thw: torch.Tensor,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-    ) -> Union[Tuple, BaseModelOutput]:
-        assert return_dict, "Only return_dict=True is supported."
-
-        encoder_states = () if output_hidden_states else None
-
-        hidden_states = self.patch_embed(pixel_values)
-        rotary_pos_emb = self.rot_pos_emb(grid_thw)
-        emb = torch.cat((rotary_pos_emb, rotary_pos_emb), dim=-1)
-        position_embeddings = emb.cos(), emb.sin()
-
-        cu_seqlens = torch.repeat_interleave(
-            grid_thw[:, 1] * grid_thw[:, 2], grid_thw[:, 0]
-        ).cumsum(dim=0, dtype=torch.int32)
-        cu_seqlens = F.pad(cu_seqlens, (1, 0), value=0)
-
-        for blk in self.blocks:
-            if output_hidden_states:
-                encoder_states = encoder_states + (hidden_states,)
-            if self.gradient_checkpointing and self.training:
-                layer_outputs = torch.utils.checkpoint.checkpoint(
-                    blk.__call__,
-                    hidden_states=hidden_states,
-                    cu_seqlens=cu_seqlens,
-                    position_embeddings=position_embeddings,
-                    use_reentrant=False,
-                )
-            else:
-                layer_outputs = blk(
-                    hidden_states=hidden_states,
-                    cu_seqlens=cu_seqlens,
-                    position_embeddings=position_embeddings,
-                )
-            hidden_states = layer_outputs
-        if output_hidden_states:
-            encoder_states = encoder_states + (hidden_states,)
-
-        if not return_dict:
-            return tuple(v for v in [hidden_states, encoder_states] if v is not None)
-        return BaseModelOutput(last_hidden_state=hidden_states, hidden_states=encoder_states)
-
-    def get_num_tokens(self):
-        return -1
-
-
-class KananaVPreTrainedModel(PreTrainedModel):
-    """
-    An abstract class to handle weights initialization and
-    a simple interface for downloading and loading pretrained models.
-    """
-
-    config_class = KananaVConfig
-    base_model_prefix = "kanana-1.5-v"
-    supports_gradient_checkpointing = True
-    _skip_keys_device_placement = "past_key_values"
-    _supports_flash_attn_2 = True
-    _supports_sdpa = True
-    _supports_cache_class = True
-    _supports_static_cache = False
-
-    _keys_to_ignore_on_load_missing = [
-        r"position_ids",
-        r"language_model.encoder.embed_tokens.weight",
-        r"language_model.decoder.embed_tokens.weight",
-        r"language_model.lm_head.weight",
-    ]
-    _no_split_modules = [
-        "CustomQwen2VLVE",
-        "DynamicCAbstractor",
-        "LlamaForCausalLM",
-        "Parameter",
-    ]
-
-    def _init_weights(self, module):
-        """Initialize the weights"""
-        if (
-            isinstance(module, nn.Conv2d)
-            or isinstance(module, nn.Embedding)
-            or isinstance(module, nn.Linear)
-        ):
-            module.weight.data.normal_(mean=0.0, std=0.02)
-            if hasattr(module, "bias") and module.bias is not None:
-                module.bias.data.zero_()
-        elif isinstance(module, nn.LayerNorm):
-            module.bias.data.zero_()
-            module.weight.data.fill_(1.0)
-        elif isinstance(module, nn.Parameter):
-            raise ValueError()
-
-
-class KananaVForConditionalGeneration(KananaVPreTrainedModel):
-    config_class = KananaVConfig
-
-    def __init__(self, config: KananaVConfig):
-        super().__init__(config)
-
-        logger.info("Build vision model ...")
-        self.vision_model = CustomQwen2VLVE._from_config(config.vision_config)
-
-        logger.info("Build projector ...")
-        self.abstractor = DynamicCAbstractor(config.projector_config,
-                                             num_input_tokens=self.vision_model.get_num_tokens())
-
-        logger.info("Build language model ...")
-        self.language_model = LlamaForCausalLM._from_config(config=config.text_config)
-
-        self.post_init()
-
-    def forward_vision(self, pixel_values: Union[torch.Tensor, List[torch.Tensor]], image_metas: Optional[dict] = None):
-        
-        # ✨ 핵심 수정: pixel_values가 리스트일 경우와 텐서일 경우를 모두 처리
-        if isinstance(pixel_values, list):
-            # 다중 이미지: 각 이미지를 처리하여 결과를 합침
-            visual_features_list = []
-            for i, pv in enumerate(pixel_values):
-                single_image_metas = {k: v[i] for k, v in image_metas.items()}
-                
-                # grid_thw 처리 수정
-                vision_grid_thw = single_image_metas["vision_grid_thw"]
-                if isinstance(vision_grid_thw, (list, tuple)):
-                    # 튜플을 리스트로 변환하여 텐서 생성
-                    grid_thw = torch.tensor([list(vision_grid_thw)]).to(pv.device)
-                else:
-                    grid_thw = torch.tensor([vision_grid_thw]).to(pv.device)
-                
-                # ✨ 최적화: 불필요한 dtype 변환 제거
-                v_outputs = self.vision_model(
-                    pixel_values=pv.unsqueeze(0), 
-                    grid_thw=grid_thw,
-                    return_dict=True, output_hidden_states=True
-                )
-                layer_index = self.config.projector_config.feature_layer_index
-                visual_features_list.append(self._get_visual_feature_at(v_outputs.hidden_states, layer_index))
-            # 경량 멀티모달: 첫 번째 것만 사용하되, downstream이 단일 텐서를 기대하므로 텐서만 반환
-            return visual_features_list[0] if len(visual_features_list) > 0 else visual_features_list
-        else:
-            # 단일 이미지 - 이미 분리된 특징 텐서
-            
-            # grid_thw가 리스트인 경우 첫 번째 요소 사용
-            grid_thw = image_metas["vision_grid_thw"]
-            if isinstance(grid_thw, list):
-                grid_thw = grid_thw[0]
-            
-            # grid_thw를 텐서로 변환
-            if not isinstance(grid_thw, torch.Tensor):
-                if isinstance(grid_thw, (list, tuple)):
-                    # 튜플을 리스트로 변환하여 텐서 생성
-                    grid_thw = torch.tensor([list(grid_thw)])
-                else:
-                    grid_thw = torch.tensor([grid_thw])
-            
-            # 디바이스 정보 추가
-            if hasattr(pixel_values, 'device'):
-                grid_thw = grid_thw.to(pixel_values.device)
-            
-            # pixel_values가 2D 특징 텐서인 경우 vision_model을 통해 처리
-            if len(pixel_values.shape) == 2:
-                # 2D 특징 텐서를 vision_model이 처리할 수 있는 형태로 변환
-                # 다중 이미지와 동일한 방식으로 처리하되, 올바른 형태로 변환
-                
-                # pixel_values를 (1, 3, H, W) 형태로 재구성
-                # 다중 이미지에서 사용하는 방식과 동일하게 처리
-                if len(pixel_values.shape) == 2:
-                    # 2D 텐서를 vision_model이 처리할 수 있는 형태로 변환
-                    # 다중 이미지에서는 이미 올바른 형태로 전달되므로 동일하게 처리
-                    
-                    # ✨ 최적화: 불필요한 dtype 변환 제거
-                    v_outputs = self.vision_model(
-                        pixel_values=pixel_values,
-                        grid_thw=grid_thw,
-                        return_dict=True, output_hidden_states=True
-                    )
-                    layer_index = self.config.projector_config.feature_layer_index
-                    return self._get_visual_feature_at(v_outputs.hidden_states, layer_index)
-                else:
-                    return pixel_values
-            
-            # ✨ 최적화: 불필요한 dtype 변환 제거
-            v_outputs = self.vision_model(
-                pixel_values=pixel_values,
-                grid_thw=grid_thw,
-                return_dict=True, output_hidden_states=True
-            )
-            layer_index = self.config.projector_config.feature_layer_index
-            return self._get_visual_feature_at(v_outputs.hidden_states, layer_index)
-
-    def forward_projector(self, visual_features: Union[torch.Tensor, List[torch.Tensor]], image_metas: Optional[dict] = None):
-        print(f"🔍 forward_projector - visual_features 형태: {visual_features.shape if hasattr(visual_features, 'shape') else type(visual_features)}")
-        
-        # ✨ 핵심 수정: visual_features가 리스트일 경우 처리
-        if isinstance(visual_features, list):
-            visual_embeds_list = []
-            for i, vf in enumerate(visual_features):
-                single_image_metas = {k: v[i] for k, v in image_metas.items()}
-                vision_grid_thw = single_image_metas["vision_grid_thw"]
-                if isinstance(vision_grid_thw, (list, tuple)):
-                    grid_thw = torch.tensor([list(vision_grid_thw)]).to(vf.device)
-                else:
-                    grid_thw = torch.tensor([vision_grid_thw]).to(vf.device)
-                visual_embeds = self.abstractor(vf, grid_thw=grid_thw)["last_hidden_state"]
-                visual_embeds_list.append(visual_embeds)
-            return torch.cat(visual_embeds_list, dim=0)
-        else:
-            # 단일 이미지
-            print(f"🔍 forward_projector - 단일 텐서 처리")
-            
-            # visual_features가 이미 처리된 특징 텐서인 경우
-            if len(visual_features.shape) == 2:
-                print(f"🔍 forward_projector - 이미 처리된 특징 텐서 감지")
-                print(f"🔍 forward_projector - 특징 텐서 형태: {visual_features.shape}")
-                
-                # grid_thw가 리스트인 경우 첫 번째 요소 사용
-                grid_thw = image_metas["vision_grid_thw"]
-                if isinstance(grid_thw, list):
-                    grid_thw = grid_thw[0]
-                
-                # grid_thw를 텐서로 변환
-                if not isinstance(grid_thw, torch.Tensor):
-                    if isinstance(grid_thw, (list, tuple)):
-                        # 튜플을 리스트로 변환하여 텐서 생성
-                        grid_thw = torch.tensor([list(grid_thw)])
-                    else:
-                        grid_thw = torch.tensor([grid_thw])
-                
-                # 디바이스 정보 추가
-                if hasattr(visual_features, 'device'):
-                    grid_thw = grid_thw.to(visual_features.device)
-                
-                print(f"🔍 forward_projector - grid_thw: {grid_thw}")
-                print(f"🔍 forward_projector - grid_thw 계산된 토큰 수: {torch.prod(grid_thw, dim=1)}")
-                print(f"🔍 forward_projector - 실제 특징 텐서 토큰 수: {visual_features.shape[0]}")
-                
-                # grid_thw가 실제 토큰 수와 맞지 않는 경우 수정
-                actual_tokens = visual_features.shape[0]
-                if torch.prod(grid_thw, dim=1).item() != actual_tokens:
-                    print(f"🔍 forward_projector - grid_thw 수정 필요")
-                    # 실제 토큰 수에 맞는 grid_thw 계산
-                    # 이미지의 실제 비율을 고려하여 계산
-                    T = 1
-                    
-                    # 이미지 메타데이터에서 실제 크기 정보 사용
-                    if 'hw_orig_resolution' in image_metas:
-                        orig_h, orig_w = image_metas['hw_orig_resolution']
-                        if isinstance(orig_h, list):
-                            orig_h = orig_h[0] if isinstance(orig_h[0], (int, float)) else orig_h[0][0]
-                        if isinstance(orig_w, list):
-                            orig_w = orig_w[0] if isinstance(orig_w[0], (int, float)) else orig_w[0][0]
-                        
-                        # 실제 비율을 유지하면서 토큰 수에 맞게 조정
-                        aspect_ratio = orig_w / orig_h
-                        H = int((actual_tokens / aspect_ratio) ** 0.5)
-                        W = int(actual_tokens / H)
-                        
-                        # 토큰 수가 맞지 않으면 조정
-                        while H * W != actual_tokens and H > 1 and W > 1:
-                            if H * W > actual_tokens:
-                                H -= 1
-                                W = int(actual_tokens / H)
-                            else:
-                                W += 1
-                                H = int(actual_tokens / W)
-                    else:
-                        # 기본값 사용
-                        H = int(actual_tokens ** 0.5)
-                        W = actual_tokens // H
-                        if actual_tokens % H != 0:
-                            W += 1
-                    
-                    corrected_grid_thw = torch.tensor([[T, H, W]])
-                    print(f"🔍 forward_projector - 수정된 grid_thw: {corrected_grid_thw}")
-                    print(f"🔍 forward_projector - 수정된 토큰 수: {torch.prod(corrected_grid_thw, dim=1)}")
-                    
-                    # 토큰 수가 맞지 않는 경우 패딩 또는 자르기
-                    expected_tokens = torch.prod(corrected_grid_thw, dim=1).item()
-                    if expected_tokens > actual_tokens:
-                        # 패딩
-                        padding_size = expected_tokens - actual_tokens
-                        padding = torch.zeros(padding_size, visual_features.shape[1], device=visual_features.device)
-                        visual_features = torch.cat([visual_features, padding], dim=0)
-                        print(f"🔍 forward_projector - 패딩 추가: {padding_size}개 토큰")
-                    elif expected_tokens < actual_tokens:
-                        # 자르기
-                        visual_features = visual_features[:expected_tokens]
-                        print(f"🔍 forward_projector - 토큰 자르기: {expected_tokens}개로")
-                    
-                    grid_thw = corrected_grid_thw
-                
-                # 특징 텐서를 abstractor에 직접 전달
-                visual_embeds = self.abstractor(visual_features, grid_thw=grid_thw)["last_hidden_state"]
-                print(f"🔍 forward_projector - abstractor 출력 형태: {visual_embeds.shape}")
-                return visual_embeds
-            else:
-                # 일반적인 vision model 출력
-                grid_thw = image_metas["vision_grid_thw"]
-                return self.abstractor(visual_features, grid_thw=grid_thw)["last_hidden_state"]
-
-    def forward_and_project_vision(self, pixel_values, image_metas: Optional[dict] = None):
-        visual_features = self.forward_vision(pixel_values, image_metas=image_metas)
-        visual_embeds = self.forward_projector(visual_features, image_metas=image_metas)
-        return visual_embeds
-
-    def _get_visual_feature_at(self, v_output, layer_index):
-        if isinstance(layer_index, list):
-            visual_features = torch.stack(v_output, dim=1)[:, layer_index]  # [B, n_scales, L, dim]
-        else:
-            visual_features = v_output[layer_index]  # [B, L, dim]
-        return visual_features
-
-    def embed_text_tokens(self, input_ids):
-        """Embed input_ids into text_embeds, ignoring media tokens (negative values)."""
-        input_ids = input_ids.clone()
-        input_ids[input_ids < 0] = 0
-
-        text_embeds = self.language_model.get_input_embeddings()(input_ids)
-        if hasattr(self.language_model, "transformer") and hasattr(
-            self.language_model.transformer, "word_embeddings_layernorm"
-        ):
-            text_embeds = self.language_model.transformer.word_embeddings_layernorm(text_embeds)
-
-        return text_embeds
-
-    def prepare_mm_inputs(
-        self,
-        input_ids: torch.FloatTensor,
-        pixel_values: Optional[list[torch.FloatTensor]] = None,
-        image_metas: Optional[dict] = None,
-        attention_mask: Optional[torch.LongTensor] = None,
-    ):
-        """Prepare multimodal inputs from input_ids and pixel_values."""
-        if pixel_values is not None:
-            # pixel_values가 리스트인 경우 각각을 변환
-            if isinstance(pixel_values, list):
-                pixel_values = [pv.to(self._get_input_dtype()) for pv in pixel_values]
-            else:
-                pixel_values = pixel_values.to(self._get_input_dtype())
-
-        if attention_mask is None:
-            attention_mask = input_ids.new_ones(*input_ids.shape)
-
-        # Get Text Embeddings
-        text_embeds = self.embed_text_tokens(input_ids)
-        flattened_text_embeds = rearrange(text_embeds, "b l d -> (b l) d")
-        flattened_input_ids = rearrange(input_ids, "b l -> (b l)")
-
-        # Get Visual Embeddings
-        if pixel_values is not None:
-            print(f"🔍 prepare_mm_inputs - pixel_values 타입: {type(pixel_values)}")
-            if hasattr(pixel_values, 'shape'):
-                print(f"🔍 prepare_mm_inputs - pixel_values 형태: {pixel_values.shape}")
-            if isinstance(pixel_values, list):
-                print(f"🔍 prepare_mm_inputs - pixel_values 길이: {len(pixel_values)}")
-            
-            # 다중 이미지 처리: 각 이미지를 개별적으로 처리
-            if isinstance(pixel_values, list) and len(pixel_values) > 1:
-                print(f"🔍 prepare_mm_inputs - 다중 이미지 처리 시작")
-                visual_embeds_list = []
-                for i, single_pixel_values in enumerate(pixel_values):
-                    print(f"🔍 prepare_mm_inputs - 이미지 {i} 처리 중")
-                    # 각 이미지에 대한 개별 image_metas 생성
-                    single_image_metas = {}
-                    for key, value_list in image_metas.items():
-                        if isinstance(value_list, list):
-                            single_image_metas[key] = value_list[i]
-                        else:
-                            single_image_metas[key] = value_list
-                    
-                    # 개별 이미지 처리
-                    single_visual_embeds = self.forward_and_project_vision(
-                        single_pixel_values.unsqueeze(0), single_image_metas
-                    )
-                    visual_embeds_list.append(single_visual_embeds)
-                
-                # 모든 이미지의 visual embeds를 연결
-                flattened_visual_embeds = torch.cat(visual_embeds_list, dim=0)
-                print(f"🔍 prepare_mm_inputs - 다중 이미지 처리 완료, 연결된 embeds 크기: {flattened_visual_embeds.shape}")
-            else:
-                # 단일 이미지 처리 (기존 방식)
-                print(f"🔍 prepare_mm_inputs - 단일 이미지 처리")
-                
-                # pixel_values가 이미 처리된 특징 텐서인 경우 (다중 이미지 결합)
-                if hasattr(pixel_values, 'shape') and len(pixel_values.shape) == 2:
-                    print(f"🔍 prepare_mm_inputs - 처리된 특징 텐서 감지, 다중 이미지로 분리 시도")
-                    
-                    # image_metas에서 이미지 개수 확인
-                    num_images = 0
-                    if isinstance(image_metas, dict) and "image_token_thw" in image_metas:
-                        num_images = len(image_metas["image_token_thw"])
-                        print(f"🔍 prepare_mm_inputs - 감지된 이미지 개수: {num_images}")
-                    
-                    if num_images > 1:
-                        print(f"🔍 prepare_mm_inputs - {num_images}개 이미지로 분리 처리")
-                        visual_embeds_list = []
-                        
-                        # 각 이미지의 실제 토큰 수 계산
-                        current_idx = 0
-                        for i in range(num_images):
-                            print(f"🔍 prepare_mm_inputs - 이미지 {i} 처리 중")
-                            
-                            # 각 이미지에 대한 개별 image_metas 생성
-                            single_image_metas = {}
-                            for key, value_list in image_metas.items():
-                                if isinstance(value_list, list):
-                                    single_image_metas[key] = value_list[i]
-                                else:
-                                    single_image_metas[key] = value_list
-                            
-                            # image_token_thw에서 실제 토큰 수 계산
-                            if "image_token_thw" in single_image_metas:
-                                token_thw = single_image_metas["image_token_thw"]
-                                if isinstance(token_thw, (list, tuple)):
-                                    tokens_per_image = int(token_thw[0]) * int(token_thw[1]) * int(token_thw[2])
-                                elif hasattr(token_thw, 'tolist'):
-                                    tlist = token_thw.tolist()
-                                    tokens_per_image = int(tlist[0]) * int(tlist[1]) * int(tlist[2])
-                                else:
-                                    tokens_per_image = int(token_thw)
-                                print(f"🔍 prepare_mm_inputs - 이미지 {i} 실제 토큰 수: {tokens_per_image}")
-                            else:
-                                # 기본값 사용
-                                tokens_per_image = pixel_values.shape[0] // num_images
-                                print(f"🔍 prepare_mm_inputs - 이미지 {i} 기본 토큰 수: {tokens_per_image}")
-                            
-                            # pixel_values에서 해당 이미지 부분 추출
-                            start_idx = current_idx
-                            end_idx = current_idx + tokens_per_image
-                            single_pixel_values = pixel_values[start_idx:end_idx]
-                            
-                            print(f"🔍 prepare_mm_inputs - 이미지 {i} 특징 형태: {single_pixel_values.shape}")
-                            
-                            # 개별 이미지 처리
-                            single_visual_embeds = self.forward_and_project_vision(
-                                single_pixel_values, single_image_metas
-                            )
-                            visual_embeds_list.append(single_visual_embeds)
-                            
-                            current_idx += tokens_per_image
-                        
-                        # 모든 이미지의 visual embeds를 연결
-                        flattened_visual_embeds = torch.cat(visual_embeds_list, dim=0)
-                        print(f"🔍 prepare_mm_inputs - 다중 이미지 처리 완료, 연결된 embeds 크기: {flattened_visual_embeds.shape}")
-                    else:
-                        # 단일 이미지 처리
-                        print(f"🔍 prepare_mm_inputs - 단일 이미지로 처리")
-                        flattened_visual_embeds = self.forward_and_project_vision(
-                            pixel_values, image_metas
-                        )
-                # pixel_values가 배치 형태인 경우 개별 이미지로 분리
-                elif hasattr(pixel_values, 'shape') and len(pixel_values.shape) == 4 and pixel_values.shape[0] > 1:
-                    print(f"🔍 prepare_mm_inputs - 배치 형태 감지, 개별 이미지로 분리")
-                    visual_embeds_list = []
-                    for i in range(pixel_values.shape[0]):
-                        print(f"🔍 prepare_mm_inputs - 배치 이미지 {i} 처리 중")
-                        # 각 이미지에 대한 개별 image_metas 생성
-                        single_image_metas = {}
-                        for key, value_list in image_metas.items():
-                            if isinstance(value_list, list):
-                                single_image_metas[key] = value_list[i]
-                            else:
-                                single_image_metas[key] = value_list
-                        
-                        # 개별 이미지 처리
-                        if isinstance(pixel_values, list):
-                            single_pixel_values = pixel_values[i:i+1]
-                        else:
-                            # pixel_values가 텐서인 경우
-                            single_pixel_values = pixel_values[i:i+1]
-                        
-                        single_visual_embeds = self.forward_and_project_vision(
-                            single_pixel_values, single_image_metas
-                        )
-                        visual_embeds_list.append(single_visual_embeds)
-                    
-                    # 모든 이미지의 visual embeds를 연결
-                    flattened_visual_embeds = torch.cat(visual_embeds_list, dim=0)
-                    print(f"🔍 prepare_mm_inputs - 다중 이미지 처리 완료, 연결된 embeds 크기: {flattened_visual_embeds.shape}")
-                    
-                    # 각 이미지의 embeds 크기 출력
-                    for i, embeds in enumerate(visual_embeds_list):
-                        print(f"🔍 prepare_mm_inputs - 이미지 {i} embeds 크기: {embeds.shape}")
-                else:
-                    # 단일 이미지 처리
-                    # image_metas가 다중 이미지 정보를 포함하는 경우 첫 번째 이미지 정보만 사용
-                    if isinstance(image_metas, dict):
-                        single_image_metas = {}
-                        for key, value_list in image_metas.items():
-                            if isinstance(value_list, list):
-                                single_image_metas[key] = value_list[0]  # 첫 번째 이미지 정보 사용
-                            else:
-                                single_image_metas[key] = value_list
-                        print(f"🔍 prepare_mm_inputs - 단일 이미지 처리, 첫 번째 이미지 정보 사용")
-                    else:
-                        single_image_metas = image_metas
-                    
-                    # 단일 이미지 처리 시 pixel_values가 리스트인지 확인
-                    if isinstance(pixel_values, list):
-                        single_pixel_values = pixel_values[0]  # 첫 번째 이미지만 사용
-                    else:
-                        single_pixel_values = pixel_values
-                    
-                    flattened_visual_embeds = self.forward_and_project_vision(
-                        single_pixel_values, single_image_metas
-                    )
-            
-            # dtype 일치를 위해 visual_embeds를 text_embeds와 같은 dtype으로 변환
-            flattened_visual_embeds = flattened_visual_embeds.to(flattened_text_embeds.dtype)
-            
-            # visual embeds와 -1 토큰 개수 확인 및 조정
-            num_visual_tokens = flattened_visual_embeds.shape[0]
-            num_neg_one_tokens = (flattened_input_ids == -1).sum().item()
-            if num_neg_one_tokens == 0:
-                # -1 토큰이 없으면 문장 시작부에 시각 토큰을 강제 삽입하기 위해 가짜 -1 토큰 하나 추가
-                fake_neg = torch.full_like(flattened_input_ids[:1], -1)
-                flattened_input_ids = torch.cat([fake_neg, flattened_input_ids], dim=0)
-                num_neg_one_tokens = 1
-            print(f"🔍 prepare_mm_inputs - visual embeds 개수: {num_visual_tokens}")
-            print(f"🔍 prepare_mm_inputs - -1 토큰 개수: {num_neg_one_tokens}")
-            
-            if num_visual_tokens != num_neg_one_tokens:
-                print(f"🔍 prepare_mm_inputs - 토큰 개수 불일치, 조정 필요")
-                if num_visual_tokens > num_neg_one_tokens:
-                    # visual embeds가 많으면 자르기
-                    flattened_visual_embeds = flattened_visual_embeds[:num_neg_one_tokens]
-                    print(f"🔍 prepare_mm_inputs - visual embeds 자르기: {num_visual_tokens} -> {num_neg_one_tokens}")
-                else:
-                    # visual embeds가 적으면 반복해서 사용
-                    repeat_times = num_neg_one_tokens // num_visual_tokens
-                    remainder = num_neg_one_tokens % num_visual_tokens
-                    
-                    if repeat_times > 0:
-                        # visual embeds를 반복
-                        repeated_embeds = flattened_visual_embeds.repeat(repeat_times, 1)
-                        if remainder > 0:
-                            # 나머지 부분 추가
-                            remainder_embeds = flattened_visual_embeds[:remainder]
-                            repeated_embeds = torch.cat([repeated_embeds, remainder_embeds], dim=0)
-                        flattened_visual_embeds = repeated_embeds
-                    else:
-                        # visual embeds가 너무 적으면 첫 번째 토큰을 반복
-                        # 최소 1개라도 유지
-                        base = flattened_visual_embeds[0:1]
-                        flattened_visual_embeds = base.repeat(max(1, num_neg_one_tokens), 1)
-                    
-                    print(f"🔍 prepare_mm_inputs - visual embeds 반복: {num_visual_tokens} -> {num_neg_one_tokens}")
-            
-            flattened_text_embeds[flattened_input_ids == -1] = flattened_visual_embeds
-
-        input_embeds = rearrange(
-            flattened_text_embeds, "(b l) d -> b l d", b=input_ids.shape[0]
-        )
-        
-        return_inputs = {
-            "inputs_embeds": input_embeds,
-            "attention_mask": attention_mask,
-        }
-        return return_inputs
-
-    def forward(
-        self,
-        pixel_values: list[torch.FloatTensor],
-        image_metas: dict[list],
-        input_ids: torch.FloatTensor,
-        seq_length: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.LongTensor] = None,
-        labels: Optional[torch.LongTensor] = None,
-        return_dict: Optional[bool] = None,
-    ):
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-        inputs = self.prepare_mm_inputs(
-            input_ids=input_ids,
-            pixel_values=pixel_values,
-            image_metas=image_metas,
-            attention_mask=attention_mask,
-        )
-
-        outputs = self.language_model(
-            **inputs,
-            labels=labels,
-            position_ids=None,
-            return_dict=return_dict,
-            output_attentions=self.config.output_attentions,
-        )
-
-        return outputs
-
- 
-    @torch.no_grad()
-    def generate(
-        self,
-        pixel_values: torch.FloatTensor = None,
-        image_metas: dict[list] = None,
-        input_ids: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.LongTensor] = None,
-        seq_length: Optional[torch.LongTensor] = None,
-        **generate_kwargs,
-    ) -> torch.LongTensor:
-        """
-        [최종 수정] 텍스트와 멀티모달 요청을 통합하여 처리하는 generate 함수
-        """
-        # --- 1. 입력 임베딩 준비 ---
-        # input_ids는 항상 필요합니다 (텍스트 프롬프트).
-        if input_ids is None:
-            # 이미지 캡셔닝과 같이 텍스트 프롬프트가 없는 경우를 위한 예외 처리
-            # (현재 사용 사례에는 해당되지 않음)
-            if pixel_values is not None:
-                # 이 경우, 시작 토큰(BOS)만으로 input_ids를 생성해야 할 수 있습니다.
-                # 지금은 간단하게 빈 텐서를 생성합니다.
-                input_ids = torch.tensor([[]], dtype=torch.long, device=self.device)
-            else:
-                raise ValueError("input_ids와 pixel_values가 모두 없습니다.")
-
-        # 멀티모달 요청인 경우, prepare_mm_inputs를 통해 텍스트와 이미지를 결합한 임베딩을 생성합니다.
-        if pixel_values is not None:
-            # 멀티모달 경로
-            if (
-                image_metas is not None
-                and image_metas.get("vision_grid_thw") is not None
-                and isinstance(image_metas.get("vision_grid_thw"), torch.Tensor)
-            ):
-                image_metas["vision_grid_thw"] = image_metas["vision_grid_thw"].to(input_ids.device)
-
-            inputs = self.prepare_mm_inputs(
-                input_ids=input_ids,
-                pixel_values=pixel_values,
-                image_metas=image_metas,
-                attention_mask=attention_mask,
-            )
-            # 최종적으로 사용할 인자는 inputs_embeds와 attention_mask
-            final_model_kwargs = {
-                "inputs_embeds": inputs.get("inputs_embeds"),
-                "attention_mask": inputs.get("attention_mask")
-            }
-        else:
-            # 텍스트 전용 경로
-            # 최종적으로 사용할 인자는 input_ids와 attention_mask
-            final_model_kwargs = {
-                "input_ids": input_ids,
-                "attention_mask": attention_mask
-            }
-
-        # --- 2. 최종 생성 ---
-        # 준비된 인자(**final_model_kwargs)와 추가 생성 옵션(**generate_kwargs)을 함께 전달합니다.
-        outputs = self.language_model.generate(
-            **final_model_kwargs,
-            **generate_kwargs,
-        )
-
-        return outputs
-
-
-    def _get_input_dtype(self):
-        dtype = next(self.vision_model.parameters()).dtype
-        return dtype

lily_llm_api/models/schemas.py

@@ -0,0 +1,184 @@
+"""
+Pydantic schemas for Lily LLM API
+"""
+from pydantic import BaseModel
+from typing import Optional, List
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    model_id: Optional[str] = None  # 기본값 제거 - 현재 로드된 모델 사용
+    max_length: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    do_sample: Optional[bool] = None
+
+class GenerateResponse(BaseModel):
+    generated_text: str
+    processing_time: float
+    model_name: str
+    image_processed: bool
+
+class MultimodalGenerateResponse(BaseModel):
+    generated_text: str
+    processing_time: float
+    model_name: str
+    model_id: Optional[str] = None
+    image_processed: bool = False
+    
+class HealthResponse(BaseModel):
+    status: str
+    model_loaded: bool
+    current_model: str
+    available_models: List[dict]
+
+class DocumentUploadResponse(BaseModel):
+    success: bool
+    document_id: str
+    message: str
+    chunks: Optional[int] = None
+    latex_count: Optional[int] = None  # LaTeX 수식 개수 필드 추가
+    error: Optional[str] = None
+    auto_response: Optional[str] = None # 자동 응답 필드 추가
+
+class RAGResponse(BaseModel):
+    success: bool
+    response: str
+    context: str
+    sources: List[dict]
+    search_results: int
+    processing_time: float
+
+# 사용자 관련 응답 모델
+class UserResponse(BaseModel):
+    success: bool
+    user_id: str
+    username: Optional[str] = None
+    email: Optional[str] = None
+    created_at: Optional[str] = None
+    error: Optional[str] = None
+
+class SessionResponse(BaseModel):
+    success: bool
+    session_id: str
+    session_name: Optional[str] = None
+    created_at: Optional[str] = None
+    error: Optional[str] = None
+
+class ChatMessageResponse(BaseModel):
+    success: bool
+    message_id: int
+    content: str
+    message_type: str
+    timestamp: str
+    error: Optional[str] = None
+
+# 인증 관련 응답 모델
+class LoginResponse(BaseModel):
+    success: bool
+    access_token: Optional[str] = None
+    refresh_token: Optional[str] = None
+    token_type: Optional[str] = None
+    user_id: Optional[str] = None
+    username: Optional[str] = None
+    error: Optional[str] = None
+
+class TokenResponse(BaseModel):
+    success: bool
+    access_token: Optional[str] = None
+    token_type: Optional[str] = None
+    error: Optional[str] = None
+
+# LoRA 관련 응답 모델
+class LoRAStatusResponse(BaseModel):
+    status: str
+    lora_available: bool
+    current_adapter: Optional[str] = None
+    base_model_loaded: bool
+    device: str
+    message: Optional[str] = None
+
+# 컨텍스트 관련 응답 모델
+class ContextStatusResponse(BaseModel):
+    status: str
+    context_manager_available: bool
+    total_sessions: int
+    sessions: dict
+    max_tokens: int
+    max_turns: int
+    strategy: str
+    message: Optional[str] = None
+
+class ContextHistoryResponse(BaseModel):
+    status: str
+    session_id: Optional[str] = None
+    context: str
+    history_length: int
+    session_summary: Optional[dict] = None
+    all_sessions: Optional[bool] = None
+    message: Optional[str] = None
+
+class AutoCleanupConfigResponse(BaseModel):
+    status: str
+    auto_cleanup_config: dict
+    message: Optional[str] = None
+
+class AutoCleanupConfigRequest(BaseModel):
+    enabled: bool = True
+    interval_turns: int = 8
+    interval_time: int = 300
+    strategy: str = "smart"
+
+# 문서 처리 관련 응답 모델
+class DocumentProcessResponse(BaseModel):
+    success: bool
+    document_id: str
+    chunks: int
+    processing_time: float
+    document_type: str
+    page_count: int
+    error: Optional[str] = None
+
+class RAGQueryRequest(BaseModel):
+    query: str
+    user_id: str = "anonymous"
+    room_id: str = "default"
+    max_results: int = 5
+    include_sources: bool = True
+
+class RAGQueryResponse(BaseModel):
+    success: bool
+    response: str
+    sources: List[dict]
+    search_results: int
+    processing_time: float
+    error: Optional[str] = None
+
+# 멀티모달 RAG 관련 응답 모델
+class MultimodalRAGResponse(BaseModel):
+    success: bool
+    response: str
+    image_processed: bool
+    processing_time: float
+    error: Optional[str] = None
+
+# 성능 모니터링 관련 응답 모델
+class PerformanceMetricsResponse(BaseModel):
+    status: str
+    metrics: dict
+    timestamp: str
+    error: Optional[str] = None
+
+# WebSocket 관련 응답 모델
+class WebSocketMessage(BaseModel):
+    type: str
+    content: str
+    user_id: str
+    room_id: str
+    timestamp: str
+
+# Celery 작업 관련 응답 모델
+class TaskStatusResponse(BaseModel):
+    task_id: str
+    status: str
+    result: Optional[dict] = None
+    error: Optional[str] = None

lily_llm_api/services/__init__.py

@@ -0,0 +1,3 @@
+"""
+Services package for Lily LLM API
+"""

lily_llm_api/services/generation_service.py

@@ -0,0 +1,583 @@
+"""
+Generation service for Lily LLM API
+"""
+import logging
+import time
+from typing import Optional, List
+from PIL import Image
+import io
+import torch
+
+logger = logging.getLogger(__name__)
+
+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,
+                 user_id: str = "anonymous", room_id: str = "default") -> dict:
+    """[최적화] 모델 생성을 처리하는 통합 동기 함수"""
+    try:
+        from .model_service import get_current_profile, get_current_model
+        from .model_service import tokenizer, processor
+        
+        current_profile = get_current_profile()
+        current_model = get_current_model()
+        
+        print(f"🔍 [DEBUG] generate_sync 시작 - prompt 길이: {len(prompt)}")
+        print(f"🔍 [DEBUG] 현재 로드된 모델: {current_profile.display_name if current_profile else 'None'}")
+        print(f"🔍 [DEBUG] 모델 타입: {type(current_profile) if current_profile else 'None'}")
+        
+        if current_profile is None:
+            print("❌ [DEBUG] 모델이 로드되지 않음")
+            return {"error": "No model loaded"}
+        
+        print(f"🔍 [DEBUG] 모델 이름: {getattr(current_profile, 'model_name', 'Unknown')}")
+        print(f"🔍 [DEBUG] 멀티모달 지원: {getattr(current_profile, 'multimodal', False)}")
+        print(f"🔍 [DEBUG] 입력 프롬프트: {prompt}")
+        print(f"🔍 [DEBUG] 입력 프롬프트 길이: {len(prompt)}")
+        print(f"🔍 [DEBUG] 이미지 데이터 존재 여부: {image_data_list is not None}")
+        print(f"🔍 [DEBUG] 이미지 데이터 개수: {len(image_data_list) if image_data_list else 0}")
+        print(f"🔍 [DEBUG] 실제 이미지 데이터 개수: {len([img for img in image_data_list if img]) if image_data_list else 0}")
+        
+        image_processed = False
+        all_pixel_values = []
+        combined_image_metas = None
+
+        # --- 1. 이미지 처리 (공식 방식) ---
+        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)}개 추가")
+        
+        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(all_image_data), 4)
+            logger.info(f"🖼️  멀티모달 처리 시작... (이미지 {max_images}개)")
+            
+            try:
+                metas_list = []
+                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")
+                            # 🔄 공식 이미지 프로세서 사용
+                            if processor and hasattr(processor, 'image_processor'):
+                                processed = processor.image_processor(pil_image)
+                                all_pixel_values.append(processed["pixel_values"])
+                                metas_list.append(processed.get("image_meta", {}))
+                            else:
+                                logger.warning(f"⚠️ 이미지 프로세서를 찾을 수 없음")
+                        except Exception as e:
+                            logger.warning(f"⚠️ 이미지 {idx} 처리 실패: {e}")
+                
+                # 🔄 메타데이터 통합 (공식 방식)
+                if metas_list:
+                    combined_image_metas = {}
+                    for key in metas_list[0].keys():
+                        combined_image_metas[key] = [meta[key] for meta in metas_list if key in meta]
+                    print(f"🔍 [DEBUG] 이미지 메타데이터: {combined_image_metas}")
+                else:
+                    combined_image_metas = {}
+            except Exception as e:
+                logger.error(f"❌ 이미지 전처리 실패: {e}")
+                combined_image_metas = {}
+
+        # --- 2. 프롬프트 구성 ---
+        print(f"🔍 [DEBUG] 프롬프트 구성 시작")
+        
+        # 컨텍스트 통합 (대화 기록 + RAG 검색 결과 포함) - 모델별 최적화
+        context_prompt = ""
+        if use_context and session_id:
+            try:
+                # 컨텍스트 관리자에서 컨텍스트 가져오기
+                try:
+                    from lily_llm_core.context_manager import context_manager
+                    context = context_manager.get_context_for_model(
+                        current_profile.model_name, 
+                        session_id
+                    )
+                    if context and len(context.strip()) > 0:
+                        context_prompt = context + "\n\n"
+                        print(f"🔍 [DEBUG] 대화 컨텍스트 포함됨 - 길이: {len(context_prompt)} (세션: {session_id})")
+                except Exception as e:
+                    print(f"⚠️ [DEBUG] 컨텍스트 로드 실패: {e}")
+                    context_prompt = ""
+                
+            except Exception as e:
+                print(f"⚠️ [DEBUG] 컨텍스트 로드 실패: {e} (세션: {session_id})")
+                context_prompt = ""
+        
+        # formatted_prompt 초기화
+        formatted_prompt = None
+        
+        # 🔄 멀티모달 프롬프트 구성 (공식 방식)
+        if all_pixel_values and len(all_pixel_values) > 0:
+            # 🔄 공식 Kanana 형식: Human: <image> 텍스트
+            formatted_prompt = f"Human: <image>{prompt}"
+            print(f"🔍 [DEBUG] 멀티모달 프롬프트 구성 (공식 형식): {formatted_prompt}")
+            image_processed = True
+        else:
+            image_processed = False
+            print(f"🔍 [DEBUG] 이미지 없음 - 텍스트-only 모드")
+            
+            # 텍스트-only 모델용 프롬프트 구성 (컨텍스트 포함)
+            if hasattr(current_profile, 'format_prompt'):
+                # Polyglot 모델일 때는 format_prompt 메서드 사용 (컨텍스트 지원)
+                if "polyglot" in current_profile.model_name.lower():
+                    # 컨텍스트와 프롬프트를 함께 전달
+                    formatted_prompt = current_profile.format_prompt(prompt, context_prompt)
+                else:
+                    # 다른 모델은 기존 방식 사용
+                    base_prompt = current_profile.format_prompt(prompt)
+                    if context_prompt:
+                        formatted_prompt = context_prompt + base_prompt
+                    else:
+                        formatted_prompt = base_prompt
+                print(f"🔍 [DEBUG] 프로필 format_prompt 사용 (컨텍스트 포함): {formatted_prompt}")
+            else:
+                # 기본 프롬프트 (fallback) - 컨텍스트 포함
+                if "polyglot" in current_profile.model_name.lower():
+                    base_prompt = f"### 사용자:\n{prompt}\n\n### 챗봇:\n"
+                else:
+                    base_prompt = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+                
+                if context_prompt:
+                    formatted_prompt = context_prompt + base_prompt
+                else:
+                    formatted_prompt = base_prompt
+                print(f"🔍 [DEBUG] 기본 프롬프트 사용 (컨텍스트 포함): {formatted_prompt}")
+        
+        print(f"🔍 [DEBUG] 프롬프트 구성 완료 - 길이: {len(formatted_prompt) if formatted_prompt else 0}")
+        print(f"🔍 [DEBUG] 최종 프롬프트: {formatted_prompt}")
+        
+        # --- 3. 토크나이징 ---
+        print(f"🔍 [DEBUG] 토크나이징 시작")
+        t_tok_start = time.time()
+        
+        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}")
+            
+            inputs = tokenizer(
+                formatted_prompt,
+                return_tensors="pt",
+                padding=True,
+                truncation=True,
+                max_length=2048,
+            )
+            if 'token_type_ids' in inputs:
+                del inputs['token_type_ids']
+                print(f"🔍 [DEBUG] token_type_ids 제거됨")
+            
+            input_ids = inputs['input_ids']
+            attention_mask = inputs['attention_mask']
+            print(f"🔍 [DEBUG] 토크나이저 출력: {list(inputs.keys())}")
+        else:
+            # 멀티모달 처리
+            print(f"🔍 [DEBUG] 멀티모달 토크나이징 경로")
+            
+            if hasattr(tokenizer, 'encode_prompt'):
+                print(f"🔍 [DEBUG] encode_prompt 메서드 사용")
+                
+                # 안전한 메타데이터 생성
+                safe_image_meta = {
+                    'image_token_thw': [[1, 1, 1]] * len(all_pixel_values),
+                    'vision_grid_thw': [[1, 1, 1]] * len(all_pixel_values)
+                }
+                
+                try:
+                    inputs = tokenizer.encode_prompt(
+                        prompt=formatted_prompt, 
+                        max_length=2048,
+                        image_meta=safe_image_meta
+                    )
+                    
+                    if 'seq_length' in inputs:
+                        del inputs['seq_length']
+                    
+                    input_ids = inputs['input_ids']
+                    attention_mask = inputs['attention_mask']
+                    
+                    # 튜플인 경우 첫 번째 요소 사용
+                    if isinstance(input_ids, tuple):
+                        input_ids = input_ids[0]
+                    if isinstance(attention_mask, tuple):
+                        attention_mask = attention_mask[0]
+                        
+                except Exception as e:
+                    print(f"❌ [DEBUG] encode_prompt 실패: {e}, 폴백 사용")
+                    # 폴백: 기본 토크나이저 사용
+                    inputs = tokenizer(
+                        formatted_prompt,
+                        return_tensors="pt",
+                        padding=True,
+                        truncation=True,
+                        max_length=2048,
+                    )
+                    if 'token_type_ids' in inputs:
+                        del inputs['token_type_ids']
+                    input_ids = inputs['input_ids']
+                    attention_mask = inputs['attention_mask']
+            else:
+                # 안전 폴백
+                print(f"🔍 [DEBUG] 기본 토크나이저 사용 (폴백)")
+                inputs = tokenizer(
+                    formatted_prompt,
+                    return_tensors="pt",
+                    padding=True,
+                    truncation=True,
+                    max_length=2048,
+                )
+                if 'token_type_ids' in inputs:
+                    del inputs['token_type_ids']
+                input_ids = inputs['input_ids']
+                attention_mask = inputs['attention_mask']
+        
+        t_tok_end = time.time()
+        print(f"🔍 [DEBUG] 토크나이징 완료 - 소요시간: {t_tok_end - t_tok_start:.3f}초")
+        
+        # 🔄 input_ids 안전하게 처리
+        if isinstance(input_ids, tuple):
+            print(f"🔍 [DEBUG] input_ids가 튜플임: {len(input_ids)}개 요소")
+            input_ids = input_ids[0]  # 첫 번째 요소 사용
+            print(f"🔍 [DEBUG] input_ids 튜플에서 첫 번째 요소 추출: {input_ids.shape}")
+        
+        # 🔄 1차원 텐서를 2차원으로 reshape
+        if len(input_ids.shape) == 1:
+            print(f"🔍 [DEBUG] 1차원 텐서를 2차원으로 reshape: {input_ids.shape} -> (1, {input_ids.shape[0]})")
+            input_ids = input_ids.unsqueeze(0)  # (seq_len,) -> (1, seq_len)
+        
+        # 🔄 attention_mask도 동일하게 처리
+        if len(attention_mask.shape) == 1:
+            print(f"🔍 [DEBUG] attention_mask 1차원을 2차원으로 reshape: {attention_mask.shape} -> (1, {attention_mask.shape[0]})")
+            attention_mask = attention_mask.unsqueeze(0)  # (seq_len,) -> (1, seq_len)
+        
+        print(f"🔍 [DEBUG] 최종 input_ids shape: {input_ids.shape}")
+        print(f"🔍 [DEBUG] 입력 토큰 수: {input_ids.shape[1]}")
+        
+        # --- 4. 생성 설정 ---
+        print(f"🔍 [DEBUG] 생성 설정 구성 시작")
+        gen_config = current_profile.get_generation_config()
+        
+        # config 파일에 명시된 eos, pad, bos 토큰 id 기본값으로 채우기
+        if 'eos_token_id' not in gen_config or gen_config['eos_token_id'] is None:
+            gen_config['eos_token_id'] = tokenizer.eos_token_id
+
+        if 'pad_token_id' not in gen_config or gen_config['pad_token_id'] is None:
+            gen_config['pad_token_id'] = tokenizer.pad_token_id or tokenizer.eos_token_id
+
+        # 필요할 경우 bos_token_id 도 설정 (generate 함수에 따라 다름)
+        if 'bos_token_id' not in gen_config and hasattr(tokenizer, 'bos_token_id'):
+            gen_config['bos_token_id'] = tokenizer.bos_token_id
+
+        # max_new_tokens, temperature 등 API 인자 받아서 덮어쓰기
+        if max_length is not None:
+            gen_config['max_new_tokens'] = max_length
+
+        if temperature is not None:
+            gen_config['temperature'] = temperature
+
+        if top_p is not None:
+            gen_config['top_p'] = top_p
+
+        if do_sample is not None:
+            gen_config['do_sample'] = do_sample
+        
+        print(f"🔍 [DEBUG] 생성 설정: {gen_config}")
+        
+        # --- 5. 실제 추론 실행 ---
+        print(f"🔍 [DEBUG] 모델 추론 시작")
+        t_gen_start = time.time()
+        
+        try:
+            # 모델 상태 확인
+            print(f"🔍 [DEBUG] 모델 디바이스: {current_model.device}")
+            print(f"🔍 [DEBUG] 입력 텐서 디바이스: {input_ids.device}")
+            print(f"🔍 [DEBUG] 모델 타입: {type(current_model)}")
+            print(f"🔍 [DEBUG] 모델 상태: {'eval' if current_model.training == False else 'training'}")
+            print(f"🔍 [DEBUG] 입력 텐서 shape: {input_ids.shape}")
+            print(f"🔍 [DEBUG] attention_mask shape: {attention_mask.shape}")
+            print(f"�� [DEBUG] all_pixel_values 존재 여부: {all_pixel_values is not None}")
+            print(f"🔍 [DEBUG] all_pixel_values 길이: {len(all_pixel_values) if all_pixel_values else 0}")
+            
+            # 입력 텐서를 모델 디바이스로 이동
+            if input_ids.device != current_model.device:
+                print(f"🔍 [DEBUG] 입력 텐서를 모델 디바이스로 이동: {input_ids.device} -> {current_model.device}")
+                input_ids = input_ids.to(current_model.device)
+                attention_mask = attention_mask.to(current_model.device)
+            
+            # 🔄 torch import 문제 해결
+            import torch
+            with torch.no_grad():
+                if all_pixel_values and len(all_pixel_values) > 0:
+                    # 멀티모달: 이미지와 텍스트 함께 처리
+                    print(f"🔍 [DEBUG] 멀티모달 추론 실행")
+                    print(f"🔍 [DEBUG] 이미지 텐서 개수: {len(all_pixel_values)}")
+                    
+                    # 이미지 텐서도 디바이스 확인
+                    pixel_values = torch.cat(all_pixel_values, dim=0)
+                    print(f"🔍 [DEBUG] 결합된 이미지 텐서 shape: {pixel_values.shape}")
+                    print(f"🔍 [DEBUG] 이미지 텐서 dtype: {pixel_values.dtype}")
+                    
+                    # 🔄 모델과 동일한 dtype으로 변환 (성능 최적화)
+                    if hasattr(current_model, 'dtype'):
+                        target_dtype = current_model.dtype
+                        if pixel_values.dtype != target_dtype:
+                            print(f"🔍 [DEBUG] 이미지 텐서 dtype 변환: {pixel_values.dtype} -> {target_dtype}")
+                            pixel_values = pixel_values.to(dtype=target_dtype)
+                    else:
+                        # 🔄 모델 dtype을 알 수 없는 경우 bfloat16 사용 (Kanana 모델 기본값)
+                        target_dtype = torch.bfloat16
+                        if pixel_values.dtype != target_dtype:
+                            print(f"🔍 [DEBUG] 이미지 텐서 dtype 변환: {pixel_values.dtype} -> {target_dtype}")
+                            pixel_values = pixel_values.to(dtype=target_dtype)
+                    
+                    if pixel_values.device != current_model.device:
+                        print(f"🔍 [DEBUG] 이미지 텐서를 모델 디바이스로 이동: {pixel_values.device} -> {current_model.device}")
+                        pixel_values = pixel_values.to(current_model.device)
+                    
+                    print(f"🔍 [DEBUG] 최종 이미지 텐서 디바이스: {pixel_values.device}")
+                    print(f"🔍 [DEBUG] 최종 이미지 텐서 dtype: {pixel_values.dtype}")
+                    print(f"🔍 [DEBUG] 모델 생성 시작 - 멀티모달")
+                    
+                    # LoRA 어댑터가 적용된 모델인지 확인
+                    try:
+                        from lily_llm_core.lora_manager import lora_manager
+                        if lora_manager and hasattr(lora_manager, 'current_adapter_name') and lora_manager.current_adapter_name:
+                            print(f"🔍 [DEBUG] LoRA 어댑터 적용됨 (멀티모달): {lora_manager.current_adapter_name}")
+                            # LoRA가 적용된 모델 사용
+                            lora_model = lora_manager.get_model()
+                            if lora_model:
+                                print(f"🔍 [DEBUG] LoRA 모델로 멀티모달 생성 실행")
+                                # 🔄 image_metas 파라미터 추가 (공식 방식)
+                                processed_image_metas = {}
+                                
+                                # 🔄 공식 방식: vision_grid_thw를 텐서로 변환
+                                if 'vision_grid_thw' in combined_image_metas:
+                                    vision_grid = combined_image_metas['vision_grid_thw']
+                                    if isinstance(vision_grid, list):
+                                        # 🔄 Kanana 모델 요구사항: (T, H, W) 형태의 3차원 텐서
+                                        if len(vision_grid) == 1 and len(vision_grid[0]) == 3:
+                                            # [(1, 34, 52)] -> (1, 34, 52) 텐서로 변환
+                                            t, h, w = vision_grid[0]
+                                            # 🔄 3차원 텐서로 변환: (1, H, W) 형태
+                                            processed_image_metas['vision_grid_thw'] = torch.tensor([[t, h, w]], dtype=torch.long)
+                                            print(f"🔍 [DEBUG] vision_grid_thw 텐서 변환: {vision_grid} -> {processed_image_metas['vision_grid_thw'].shape}")
+                                        else:
+                                            # 🔄 다른 형태의 경우 원본 유지
+                                            processed_image_metas['vision_grid_thw'] = torch.tensor(vision_grid, dtype=torch.long)
+                                            print(f"🔍 [DEBUG] vision_grid_thw 텐서 변환 (기본): {vision_grid} -> {processed_image_metas['vision_grid_thw'].shape}")
+                                    else:
+                                        processed_image_metas['vision_grid_thw'] = vision_grid
+                                
+                                # 🔄 다른 메타데이터는 그대로 유지
+                                for key, value in combined_image_metas.items():
+                                    if key != 'vision_grid_thw':
+                                        processed_image_metas[key] = value
+                                
+                                generate_kwargs = {
+                                    'input_ids': input_ids,
+                                    'attention_mask': attention_mask,
+                                    'pixel_values': pixel_values,
+                                    'image_metas': processed_image_metas,  # 🔄 처리된 이미지 메타데이터
+                                    **gen_config
+                                }
+                                print(f"🔍 [DEBUG] LoRA 모델 생성 파라미터: {list(generate_kwargs.keys())}")
+                                print(f"🔍 [DEBUG] 처리된 image_metas: {list(processed_image_metas.keys())}")
+                                print(f"🔍 [DEBUG] 모델 생성 시작... (타임아웃 없음)")
+                                
+                                generated_ids = lora_model.generate(**generate_kwargs)
+                            else:
+                                print(f"⚠️ [DEBUG] LoRA 모델을 가져올 수 없음, 기본 모델 사용")
+                                generated_ids = current_model.generate(
+                                    input_ids=input_ids,
+                                    attention_mask=attention_mask,
+                                    pixel_values=pixel_values,
+                                    **gen_config
+                                )
+                        else:
+                            print(f"🔍 [DEBUG] LoRA 어댑터 없음 (멀티모달), 기본 모델 사용")
+                            generated_ids = current_model.generate(
+                                input_ids=input_ids,
+                                attention_mask=attention_mask,
+                                pixel_values=pixel_values,
+                                **gen_config
+                            )
+                    except ImportError:
+                        print(f"🔍 [DEBUG] LoRA 지원 안됨, 기본 모델 사용")
+                        generated_ids = current_model.generate(
+                            input_ids=input_ids,
+                            attention_mask=attention_mask,
+                            pixel_values=pixel_values,
+                            **gen_config
+                        )
+                                                        
+                else:
+                    # 텍스트-only: 기존 방식
+                    print(f"🔍 [DEBUG] 텍스트-only 추론 실행")
+                    print(f"🔍 [DEBUG] 생성 설정: {gen_config}")
+                    
+                    # 추가 성능 최적화 설정
+                    gen_config['use_cache'] = True  # 캐시 사용으로 속도 향상
+                    
+                    # PAD 토큰 설정 - 모델 프로필 설정 우선
+                    if 'pad_token_id' not in gen_config:
+                        # 프로필에 설정이 없을 때만 기본값 사용
+                        if tokenizer.pad_token_id is not None:
+                            gen_config['pad_token_id'] = tokenizer.pad_token_id
+                            print(f"🔍 [DEBUG] PAD 토큰 설정: 토크나이저 기본값 사용 (ID: {tokenizer.pad_token_id})")
+                        else:
+                            gen_config['pad_token_id'] = None
+                            print(f"🔍 [DEBUG] PAD 토큰 설정: None (토크나이저에 PAD 토큰 없음)")
+                    
+                    # 토큰 설정 - 프로필에서 설정된 값 우선 사용
+                    if 'eos_token_id' not in gen_config or gen_config['eos_token_id'] is None:
+                        if tokenizer.eos_token_id is not None:
+                            gen_config['eos_token_id'] = tokenizer.eos_token_id
+                            print(f"🔍 [DEBUG] EOS 토큰 설정: {tokenizer.eos_token_id}")
+                        else:
+                            gen_config['eos_token_id'] = None
+                            print(f"🔍 [DEBUG] EOS 토큰 설정: None (자동 처리)")
+                    
+                    if 'pad_token_id' not in gen_config or gen_config['pad_token_id'] is None:
+                        if tokenizer.pad_token_id is not None:
+                            gen_config['pad_token_id'] = tokenizer.pad_token_id
+                        else:
+                            gen_config['pad_token_id'] = None
+                    
+                    if 'bos_token_id' not in gen_config or gen_config['bos_token_id'] is None:
+                        if hasattr(tokenizer, 'bos_token_id') and tokenizer.bos_token_id is not None:
+                            gen_config['bos_token_id'] = tokenizer.bos_token_id
+                        else:
+                            gen_config['bos_token_id'] = None
+                    
+                    print(f"🔍 [DEBUG] 최종 토큰 설정: EOS={gen_config['eos_token_id']}, PAD={gen_config['pad_token_id']}, BOS={gen_config.get('bos_token_id')}")
+                    
+                    # 생성 설정 최종 확인
+                    print(f"🔍 [DEBUG] 최종 생성 설정: {gen_config}")
+                    
+                    print(f"🔍 [DEBUG] 모델 생성 시작 - 텍스트만")
+                    print(f"🔍 [DEBUG] 최종 입력 텐서 디바이스: {input_ids.device}")
+                    print(f"🔍 [DEBUG] 최종 attention_mask 디바이스: {attention_mask.device}")
+                    
+                    # 모델 생성 진행 상황 모니터링을 위한 콜백 추가
+                    print(f"🔍 [DEBUG] 모델 생성 시작 시간: {time.time()}")
+                    
+                    # LoRA 어댑터가 적용된 모델인지 확인
+                    try:
+                        from lily_llm_core.lora_manager import lora_manager
+                        if lora_manager and hasattr(lora_manager, 'current_adapter_name') and lora_manager.current_adapter_name:
+                            print(f"🔍 [DEBUG] LoRA 어댑터 적용됨: {lora_manager.current_adapter_name}")
+                            # LoRA가 적용된 모델 사용
+                            lora_model = lora_manager.get_model()
+                            if lora_model:
+                                print(f"🔍 [DEBUG] LoRA 모델로 생성 실행")
+                                # LoRA 모델용 입력 처리 (token_type_ids 제거)
+                                lora_inputs = {
+                                    'input_ids': input_ids,
+                                    'attention_mask': attention_mask
+                                }
+                                
+                                generated_ids = lora_model.generate(
+                                    **lora_inputs,
+                                    **gen_config
+                                )
+                            else:
+                                print(f"⚠️ [DEBUG] LoRA 모델을 가져올 수 없음, 기본 모델 사용")
+                                generated_ids = current_model.generate(
+                                    input_ids=input_ids,
+                                    attention_mask=attention_mask,
+                                    **gen_config
+                                )
+                        else:
+                            print(f"🔍 [DEBUG] LoRA 어댑터 없음, 기본 모델 사용")
+                            generated_ids = current_model.generate(
+                                input_ids=input_ids,
+                                attention_mask=attention_mask,
+                                **gen_config
+                            )
+                    except ImportError:
+                        print(f"🔍 [DEBUG] LoRA 지원 안됨, 기본 모델 사용")
+                        generated_ids = current_model.generate(
+                            input_ids=input_ids,
+                            attention_mask=attention_mask,
+                            **gen_config
+                        )
+                    
+                    print(f"🔍 [DEBUG] 모델 생성 완료 시간: {time.time()}")
+            
+            t_gen_end = time.time()
+            print(f"🔍 [DEBUG] 모델 추론 완료 - 소요시간: {t_gen_end - t_gen_start:.3f}초")
+            print(f"🔍 [DEBUG] 생성된 토큰 수: {generated_ids.shape[1] - input_ids.shape[1]}")
+            print(f"🔍 [DEBUG] 최종 generated_ids shape: {generated_ids.shape}")
+            print(f"🔍 [DEBUG] 최종 generated_ids 디바이스: {generated_ids.device}")
+            print(f"🔍 [DEBUG] 최종 generated_ids dtype: {generated_ids.dtype}")
+            
+        except Exception as e:
+            print(f"❌ [DEBUG] 모델 추론 중 에러 발생: {str(e)}")
+            print(f"❌ [DEBUG] 에러 타입: {type(e).__name__}")
+            print(f"❌ [DEBUG] 에러 상세: {str(e)}")
+            import traceback
+            traceback.print_exc()
+            return {"error": f"Generation failed: {str(e)}"}
+        
+        # --- 6. 응답 추출 ---
+        print(f"🔍 [DEBUG] 응답 추출 시작")
+        t_decode_start = time.time()
+        
+        try:
+            # 생성된 텍스트 디코딩
+            full_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
+            print(f"🔍 [DEBUG] 전체 텍스트 길이: {len(full_text)}")
+            print(f"🔍 [DEBUG] 전체 생성 텍스트 (Raw): \n---\n{full_text}\n---")
+            print(f"🔍 [DEBUG] 사용된 프롬프트: {formatted_prompt}")
+            
+            # 프로필별 응답 추출 (안전한 방식)
+            if hasattr(current_profile, 'extract_response'):
+                try:
+                    response = current_profile.extract_response(full_text, formatted_prompt)
+                    print(f"🔍 [DEBUG] 프로필 extract_response 사용 성공")
+                except Exception as extract_error:
+                    print(f"⚠️ [DEBUG] 프로필 extract_response 실패: {extract_error}")
+                    # 폴백: 기본 응답 추출
+                    response = full_text.replace(formatted_prompt, "").strip() if formatted_prompt else full_text
+                    print(f"🔍 [DEBUG] 기본 응답 추출 사용 (폴백)")
+            else:
+                # 기본 응답 추출
+                response = full_text.replace(formatted_prompt, "").strip() if formatted_prompt else full_text
+                print(f"🔍 [DEBUG] 기본 응답 추출 사용")
+            
+
+            
+            print(f"🔍 [DEBUG] 추출된 응답 길이: {len(response)}")
+            print(f"🔍 [DEBUG] 최종 응답: {response}")
+            
+            t_decode_end = time.time()
+            print(f"🔍 [DEBUG] 응답 추출 완료 - 소요시간: {t_decode_end - t_decode_start:.3f}초")
+            
+        except Exception as e:
+            print(f"❌ [DEBUG] 응답 추출 중 에러 발생: {str(e)}")
+            import traceback
+            traceback.print_exc()
+            return {"error": f"Response extraction failed: {str(e)}"}
+        
+        # --- 7. 결과 반환 ---
+        total_time = time.time() - t_tok_start
+        print(f"🔍 [DEBUG] 전체 처리 완료 - 총 소요시간: {total_time:.3f}초")
+        
+        return {
+            "generated_text": response,
+            "processing_time": total_time,
+            "model_name": current_profile.display_name,
+            "image_processed": image_processed,
+            "tokens_generated": generated_ids.shape[1] - input_ids.shape[1],
+            "total_tokens": generated_ids.shape[1]
+        }
+        
+    except Exception as e:
+        print(f"❌ [DEBUG] generate_sync 전체 에러: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return {"error": str(e)}

lily_llm_api/services/model_service.py

@@ -0,0 +1,91 @@
+"""
+Model service for Lily LLM API
+"""
+import logging
+import asyncio
+import concurrent.futures
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# 전역 변수들
+current_model = None  # 🔄 현재 로드된 모델 인스턴스
+current_profile = None  # 🔄 현재 선택된 모델 프로필
+model_loaded = False  # 🔄 모델 로드 상태
+model = None
+tokenizer = None
+processor = None
+executor = concurrent.futures.ThreadPoolExecutor()
+
+def get_current_model():
+    """현재 로드된 모델 반환"""
+    return current_model
+
+def get_current_profile():
+    """현재 선택된 모델 프로필 반환"""
+    return current_profile
+
+def is_model_loaded():
+    """모델 로드 상태 반환"""
+    return model_loaded
+
+async def load_model_async(model_id: str):
+    """모델을 비동기적으로 로딩"""
+    loop = asyncio.get_event_loop()
+    await loop.run_in_executor(executor, load_model_sync, model_id)
+
+def load_model_sync(model_id: str):
+    """모델 및 관련 프로세서를 동기적으로 로딩 (최종 수정본)"""
+    global model, tokenizer, processor, current_profile, current_model, model_loaded
+    
+    try:
+        if model is not None:
+            logger.info("🗑️ 기존 모델 언로드 중...")
+            del model
+            del tokenizer
+            del processor
+            model, tokenizer, processor = None, None, None
+            import gc
+            gc.collect()
+            logger.info("✅ 기존 모델 언로드 완료")
+        
+        logger.info(f"📥 '{model_id}' 모델 로딩 시작...")
+        from ..models import get_model_profile
+        current_profile = get_model_profile(model_id)
+        
+        # 이제 load_model은 (model, processor)를 반환합니다.
+        model, processor = current_profile.load_model()
+        
+        # 🔄 전역 변수에 모델 설정 (LoRA에서 사용)
+        current_model = model
+        
+        # processor에서 tokenizer를 꺼내 전역 변수에 할당합니다.
+        if hasattr(processor, 'tokenizer'):
+            tokenizer = processor.tokenizer
+        else:
+            # processor 자체가 tokenizer 역할도 할 수 있는 경우
+            tokenizer = processor
+        
+        logger.info(f"✅ '{current_profile.display_name}' 모델 로딩 완료!")
+        
+        # 🔄 LoRA 기본 모델 자동 로드 (공통 함수 사용)
+        try:
+            from lily_llm_core.lora_manager import get_lora_manager, lora_manager
+            if lora_manager:
+                from ..utils.lora_utils import setup_lora_for_model
+                setup_lora_for_model(current_profile, lora_manager)
+        except ImportError:
+            logger.warning("⚠️ LoRA 관리자 import 실패")
+        
+        model_loaded = True
+        
+    except Exception as e:
+        logger.error(f"❌ load_model_sync 실패: {e}")
+        import traceback
+        logger.error(f"🔍 전체 에러: {traceback.format_exc()}")
+        model_loaded = False
+        raise
+
+def shutdown_executor():
+    """스레드 풀 실행기 종료"""
+    executor.shutdown(wait=True)

lily_llm_api/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Utilities package for Lily LLM API
+"""

lily_llm_api/utils/lora_utils.py

@@ -0,0 +1,124 @@
+"""
+LoRA utilities for Lily LLM API
+"""
+import logging
+
+logger = logging.getLogger(__name__)
+
+def setup_lora_for_model(profile, lora_manager):
+    """모델 프로필에 따른 LoRA 설정 (공통 함수)"""
+    if not lora_manager:
+        logger.warning("⚠️ LoRA가 사용 불가능하여 자동 설정 건너뜀")
+        return False
+    
+    try:
+        logger.info("🔧 LoRA 자동 설정 시작...")
+        
+        # 🔄 모델 프로필에서 경로 및 타입 정보 가져오기
+        current_model_path = None
+        model_type = "causal_lm"  # 기본값
+        
+        # 🔄 모델 프로필에서 경로 및 타입 정보 가져오기
+        if hasattr(profile, 'local_path') and profile.local_path:
+            # 로컬 환경: 로컬 경로 사용
+            current_model_path = profile.local_path
+            # 🔄 local_path 사용 시에도 model_type 설정 필요
+            if hasattr(profile, 'model_id') and profile.model_id:
+                model_id = profile.model_id
+                if model_id == "kanana-1.5-v-3b-instruct":
+                    model_type = "vision2seq"  # 🔄 kanana는 vision2seq 타입
+                else:
+                    model_type = "causal_lm"  # 기본값
+            logger.info(f"🔍 모델 프로필에서 로컬 경로 사용: {current_model_path}")
+            logger.info(f"🔍 결정된 모델 타입: {model_type}")
+        elif hasattr(profile, 'model_id') and profile.model_id:
+            # 모델 ID를 기반으로 경로 결정
+            model_id = profile.model_id
+            logger.info(f"🔍 모델 ID 기반 경로 결정: {model_id}")
+            
+            # 🔄 환경에 따른 경로 결정
+            if hasattr(profile, 'is_local') and profile.is_local:
+                # 로컬 환경: 로컬 경로 사용
+                if model_id == "polyglot-ko-1.3b-chat":
+                    current_model_path = "./lily_llm_core/models/polyglot_ko_1_3b_chat"
+                    model_type = "causal_lm"
+                elif model_id == "kanana-1.5-v-3b-instruct":
+                    current_model_path = "./lily_llm_core/models/kanana_1_5_v_3b_instruct"
+                    model_type = "vision2seq"  # 🔄 kanana는 vision2seq 타입
+                elif model_id == "polyglot-ko-5.8b-chat":
+                    current_model_path = "./lily_llm_core/models/polyglot_ko_5_8b_chat"
+                    model_type = "causal_lm"
+            else:
+                # 배포 환경: HF 모델명 사용 (로컬 경로 없음)
+                current_model_path = None
+                logger.info(f"🔍 배포 환경: LoRA 설정 건너뜀 (HF 모델)")
+                return False
+            
+            logger.info(f"🔍 결정된 모델 경로: {current_model_path}")
+            logger.info(f"🔍 결정된 모델 타입: {model_type}")
+        
+        if not current_model_path:
+            logger.warning("⚠️ 현재 모델의 경로를 찾을 수 없어 LoRA 자동 로드 건너뜀")
+            return False
+        
+        logger.info(f"🔍 LoRA 모델 경로: {current_model_path}")
+        logger.info(f"🔍 LoRA 모델 타입: {model_type}")
+        
+        # 🔄 이미 로드된 메인 모델을 LoRA에 직접 적용 (중복 로드 방지)
+        logger.info("🔧 기존 메인 모델에 LoRA 직접 적용 시작...")
+        
+        # 🔄 lora_manager에 기존 메인 모델 설정
+        if hasattr(lora_manager, 'base_model') and lora_manager.base_model is None:
+            # 전역 변수에서 메인 모델 가져오기
+            from ..services.model_service import get_current_model
+            current_model = get_current_model()
+            if current_model is not None:
+                lora_manager.base_model = current_model
+                logger.info("✅ 기존 메인 모델을 LoRA 관리자에 설정 완료")
+            else:
+                logger.warning("⚠️ 메인 모델을 찾을 수 없어 LoRA 설정 건너뜀")
+                return False
+        
+        # LoRA 설정 생성
+        logger.info("🔧 LoRA 설정 생성 시작...")
+        
+        # 🔄 모델별 target modules 설정
+        if model_type == "vision2seq" and "kanana" in profile.model_id:
+            # Kanana 모델: Llama 기반 language model 사용 (첫 번째 레이어만 사용)
+            target_modules = [
+                "language_model.model.layers.0.self_attn.q_proj",
+                "language_model.model.layers.0.self_attn.k_proj", 
+                "language_model.model.layers.0.self_attn.v_proj",
+                "language_model.model.layers.0.self_attn.o_proj",
+                "language_model.model.layers.0.mlp.gate_proj",
+                "language_model.model.layers.0.mlp.up_proj",
+                "language_model.model.layers.0.mlp.down_proj"
+            ]
+        else:
+            # 기존 모델들: GPTNeoX 기반
+            target_modules = ["query_key_value", "mlp.dense_h_to_4h", "mlp.dense_4h_to_h"]
+        
+        lora_config = lora_manager.create_lora_config(
+            r=16,
+            lora_alpha=32,
+            lora_dropout=0.1,
+            bias="none",
+            task_type="CAUSAL_LM" if model_type == "causal_lm" else "VISION_2_SEQ",
+            target_modules=target_modules
+        )
+        logger.info("✅ LoRA 설정 생성 완료")
+        
+        # LoRA 어댑터 적용 (기존 메인 모델에 직접)
+        logger.info("🔧 LoRA 어댑터 적용 시작...")
+        adapter_success = lora_manager.apply_lora_to_model("auto_adapter")
+        if adapter_success:
+            logger.info("✅ LoRA 어댑터 적용 완료: auto_adapter")
+            logger.info("🎉 LoRA 자동 설정 완료!")
+            return True
+        else:
+            logger.error("❌ LoRA 어댑터 적용 실패")
+            return False
+            
+    except Exception as e:
+        logger.error(f"❌ LoRA 자동 설정 중 오류: {e}")
+        return False

lily_llm_api/utils/system_utils.py

@@ -0,0 +1,65 @@
+"""
+System utilities for Lily LLM API
+"""
+import os
+import torch
+import logging
+
+logger = logging.getLogger(__name__)
+
+def configure_cpu_threads():
+    """CPU 스레드 환경 최적화 (vCPU 수에 맞게 조정)."""
+    print(f"🔍 [DEBUG] configure_cpu_threads 시작")
+    try:
+        # 기본값: 환경변수 또는 시스템 CPU 수를 사용하되 과도한 스레드 방지
+        env_threads = os.getenv("CPU_THREADS")
+        if env_threads is not None:
+            threads = max(1, int(env_threads))
+        else:
+            detected = os.cpu_count() or 2
+            # 컨테이너/서버의 vCPU 수를 그대로 사용하되 상한 16 적용
+            threads = max(1, min(detected, 16))
+
+        # OpenMP/MKL/numexpr
+        os.environ["OMP_NUM_THREADS"] = str(threads)
+        os.environ["MKL_NUM_THREADS"] = str(threads)
+        os.environ.setdefault("NUMEXPR_NUM_THREADS", str(threads))
+        os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+        # PyTorch 내부 스레드 설정
+        try:
+            torch.set_num_threads(threads)
+        except Exception:
+            pass
+        try:
+            # 연산 간 스레드 풀은 1~2 권장(컨텍스트 스위칭 비용 절감)
+            torch.set_num_interop_threads(1 if threads <= 4 else 2)
+        except Exception:
+            pass
+
+        logger.info(f"🧵 CPU thread config -> OMP/MKL/numexpr={threads}, torch_threads={threads}")
+    except Exception as e:
+        logger.warning(f"⚠️ CPU 스레드 설정 실패: {e}")
+    print(f"🔍 [DEBUG] configure_cpu_threads 종료")
+
+def select_model_interactive():
+    """인터랙티브 모델 선택"""
+    from ..models import list_available_models
+    
+    available_models = list_available_models()
+    
+    print("\n" + "="*60 + "\n🤖 Lily LLM API v2 - 모델 선택\n" + "="*60)
+    for i, model_info in enumerate(available_models, 1):
+        print(f"{i:2d}. {model_info['name']} ({model_info['model_id']})")
+    while True:
+        try:
+            # choice = input(f"\n📝 사용할 모델 번호를 선택하세요 (1-{len(available_models)}): ")
+            # selected_model = available_models[int(choice) - 1]
+            selected_model = available_models[1]
+            print(f"\n✅ '{selected_model['name']}' 모델을 선택했습니다.")
+            return selected_model['model_id']
+        except (ValueError, IndexError):
+            print(f"❌ 1에서 {len(available_models)} 사이의 숫자를 입력해주세요.")
+        except KeyboardInterrupt: 
+            import sys
+            sys.exit("\n\n👋 프로그램을 종료합니다.")

lily_llm_core/document_processor.py

@@ -195,7 +195,7 @@ class DocumentProcessor:
                 logger.warning(f"⚠️ 수식 추출 엔진 {formula_ocr_engine} 사용 불가, EasyOCR로 대체")
         else:
             self.formula_extractor_available = False
-        
+    
         logger.info(f"🚀 DocumentProcessor 초기화 완료 (OCR: {'EasyOCR' if self.ocr_reader else 'None'}, 수식: {formula_ocr_engine})")
     
     def get_file_type(self, file_path: str) -> str:
@@ -222,7 +222,7 @@ class DocumentProcessor:
             documents = loader.load()
             logger.info(f"📄 문서 로드 완료: {len(documents)}개 청크")
             return documents
-            
+                
         except Exception as e:
             logger.error(f"❌ 문서 로드 실패: {e}")
             return []
@@ -298,7 +298,7 @@ class DocumentProcessor:
         except Exception as e:
             logger.error(f"❌ 문서 처리 실패: {e}")
             return []
-    
+
     def _process_pdf_hybrid(self, pdf_path: str) -> List[Document]:
         """
         실무 수준 PDF 처리 (구조 분석 + 공간적 관계 매핑)
@@ -427,17 +427,17 @@ class DocumentProcessor:
                         # 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_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)
+                            img_rect = self._get_image_rect(page, xref)
                         
                         if img_rect:
                             bbox = BoundingBox(
@@ -562,7 +562,7 @@ class DocumentProcessor:
             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}")
         
@@ -687,9 +687,9 @@ class DocumentProcessor:
                 
                 # Document 객체 생성
                 doc = Document(
-                    page_content=page_content,
-                    metadata=metadata
-                )
+                        page_content=page_content,
+                        metadata=metadata
+                    )
                 documents.append(doc)
                 
                 logger.info(f"📄 페이지 {page.page_num} Document 생성: "
@@ -767,7 +767,7 @@ class DocumentProcessor:
         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:
@@ -882,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 사용 

run_server.py

@@ -19,7 +19,7 @@ if __name__ == "__main__":
     
     try:
         uvicorn.run(
-            "lily_llm_api.app_v2:app",
+            "lily_llm_api.app_v2_modular:app",
             host="0.0.0.0",
             port=8001,
             reload=False,

run_server_v2.py

@@ -11,7 +11,7 @@ import uvicorn
 # 프로젝트 루트를 Python 경로에 추가
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-from lily_llm_api.app_v2 import app
+from lily_llm_api.app import app
 
 def main():
     """메인 함수"""