Fresh start for HF Spaces deployment

.dockerignore

@@ -0,0 +1,119 @@
+# Git
+.git
+.gitignore
+.env
+lily_llm_media/
+lily_llm_env/
+lily_llm_core/models/
+lily_llm_ignore/
+vector_stores/
+latex_ocr_env/
+lily_llm_utils/LaTeX-OCR/
+hearth_llm_model/
+ocr_models/
+latex_ocr_faiss_simple/
+latex_ocr_faiss_stores/
+uploads/
+simple_stores/
+notebooks/
+lily_llm_etc/
+*.safetensors
+*.pth
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv/
+.env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+*.out
+
+# Cache
+cache/
+.cache/
+__pycache__/
+
+# Temporary files
+temp/
+tmp/
+*.tmp
+*.temp
+
+# Large model files (will be downloaded at runtime from Hugging Face Hub)
+*.bin
+*.safetensors
+*.pt
+*.pth
+models/*/
+lily_llm_core/models/*/
+
+# Data files
+data/
+uploads/
+vector_stores/
+
+# Backup files
+backup/
+*.backup
+*.bak
+
+# Documentation (except README)
+docs/
+*.md
+!README_huggingface.md
+
+# Test files
+test_*
+*_test.py
+tests/
+
+# Docker
+Dockerfile
+Dockerfile.*
+!Dockerfile.huggingface
+docker-compose.yml
+docker-compose.yaml
+
+# Other configs
+.env
+.env.*
+config.yaml
+config.json

.gitattributes

@@ -0,0 +1,2 @@
+*.pdf filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,230 @@
+.github/
+.env
+lily_llm_env/ 
+lily_llm_core/models/
+__pycache__/ 
+*.pyc 
+.ipynb_checkpoints/ 
+lily_llm_media/
+vector_stores/
+latex_ocr_env/
+lily_llm_ignore/
+lily_llm_utils/LaTeX-OCR/
+hearth_llm_model/
+ocr_models/
+latex_ocr_faiss_simple/
+latex_ocr_faiss_stores/
+uploads/
+simple_stores/
+notebooks/
+lily_llm_etc/
+*.safetensors
+*.pth
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "terminal.integrated.cwd": "c:/Project/lily_generate_project/lily_generate_package"
+}
+  

DEPLOYMENT_CHECKLIST.md

@@ -0,0 +1,152 @@
+# 🚀 Lily LLM API - Hugging Face Spaces 배포 체크리스트
+
+## ✅ 배포 전 체크리스트
+
+### 📋 필수 파일 확인
+- [ ] `Dockerfile.huggingface` - Docker 설정 파일
+- [ ] `app_huggingface.py` - Hugging Face Spaces 진입점
+- [ ] `requirements_full.txt` - 완전한 의존성 패키지 목록
+- [ ] `README_huggingface.md` - 프로젝트 설명 문서
+- [ ] `.dockerignore` - Docker 빌드 제외 파일 목록
+
+### 🔧 프로젝트 구조 확인
+- [ ] `lily_llm_api/` - FastAPI 서버 코드
+- [ ] `lily_llm_core/` - 핵심 RAG 및 AI 로직
+- [ ] `lily_llm_utils/` - 유틸리티 함수들
+- [ ] 모델 파일들이 올바른 경로에 위치
+
+### 🌐 Hugging Face 계정 준비
+- [ ] Hugging Face 계정 생성 완료
+- [ ] Write 권한이 있는 Access Token 생성
+- [ ] 토큰을 안전한 곳에 저장
+
+## 🚀 배포 단계
+
+### 1단계: Hugging Face Space 생성
+- [ ] [Hugging Face Spaces](https://huggingface.co/spaces) 접속
+- [ ] "Create new Space" 클릭
+- [ ] 다음 설정으로 생성:
+  - [ ] **Space name**: `lily-llm-api` (또는 원하는 이름)
+  - [ ] **SDK**: `Docker` 선택
+  - [ ] **Hardware**: `CPU basic` (무료) 또는 `CPU upgrade` (유료)
+  - [ ] **Visibility**: `Public` 또는 `Private`
+
+### 2단계: 파일 업로드
+- [ ] Space 저장소 클론 또는 웹 인터페이스 사용
+- [ ] 필수 파일들을 올바른 이름으로 복사:
+  - [ ] `Dockerfile.huggingface` → `Dockerfile`
+  - [ ] `requirements_full.txt` → `requirements.txt`
+  - [ ] `README_huggingface.md` → `README.md`
+- [ ] 소스 코드 디렉토리들 복사
+- [ ] Git commit 및 push (Git 방식 사용 시)
+
+### 3단계: 환경 변수 설정
+Space Settings > Variables에서 설정:
+- [ ] `HOST=0.0.0.0`
+- [ ] `PORT=7860`
+- [ ] `PYTHONPATH=/app`
+- [ ] `PYTHONUNBUFFERED=1`
+- [ ] `TOKENIZERS_PARALLELISM=false`
+- [ ] `OMP_NUM_THREADS=1`
+- [ ] `MKL_NUM_THREADS=1`
+
+### 4단계: 빌드 및 배포 확인
+- [ ] Space 페이지에서 빌드 로그 확인
+- [ ] 오류 발생 시 로그 분석 및 수정
+- [ ] 빌드 완료 후 앱 실행 확인
+
+## 🧪 테스트 체크리스트
+
+### API 기본 테스트
+- [ ] Health Check: `GET /health`
+```bash
+curl https://YOUR_USERNAME-lily-llm-api.hf.space/health
+```
+
+- [ ] 모델 목록: `GET /models`
+```bash
+curl https://YOUR_USERNAME-lily-llm-api.hf.space/models
+```
+
+- [ ] 텍스트 생성: `POST /generate`
+```bash
+curl -X POST https://YOUR_USERNAME-lily-llm-api.hf.space/generate \
+  -F "prompt=안녕하세요! 테스트 메시지입니다."
+```
+
+### 고급 기능 테스트
+- [ ] 이미지 처리 테스트
+- [ ] RAG 시스템 테스트 (문서 업로드 및 질의)
+- [ ] 멀티모달 기능 테스트
+
+### 성능 테스트
+- [ ] 응답 시간 측정
+- [ ] 동시 요청 처리 확인
+- [ ] 메모리 사용량 모니터링
+
+## 🔗 Hearth Chat 연동 준비
+
+### URL 기록
+배포 완료 후 다음 URL 기록:
+- [ ] Hugging Face Space URL: `https://YOUR_USERNAME-lily-llm-api.hf.space`
+- [ ] API 문서 URL: `https://YOUR_USERNAME-lily-llm-api.hf.space/docs`
+
+### Hearth Chat 설정 업데이트
+- [ ] AI 설정 모달에 Lily LLM 옵션 추가
+- [ ] 백엔드 consumers.py에 Hugging Face API 호출 로직 추가
+- [ ] 환경 변수에 Lily LLM API URL 설정
+
+## ❌ 문제 해결
+
+### 일반적인 오류와 해결책
+
+**빌드 실패**
+- [ ] `requirements.txt` 의존성 확인
+- [ ] `Dockerfile` 문법 오류 확인
+- [ ] `.dockerignore` 파일 확인
+
+**메모리 부족**
+- [ ] 불필요한 패키지 제거
+- [ ] 모델 크기 최적화
+- [ ] Hardware 업그레이드 고려
+
+**모듈 Import 오류**
+- [ ] `PYTHONPATH` 환경 변수 확인
+- [ ] 파일 경로 및 구조 확인
+- [ ] 의존성 패키지 버전 확인
+
+**API 응답 없음**
+- [ ] 포트 설정 확인 (7860)
+- [ ] 방화벽 설정 확인
+- [ ] 로그에서 오류 메시지 확인
+
+## 📊 모니터링 설정
+
+### 배포 후 모니터링
+- [ ] Space 대시보드에서 사용량 확인
+- [ ] 로그 정기적 확인
+- [ ] 성능 메트릭 모니터링
+- [ ] 사용자 피드백 수집
+
+### 유지보수 계획
+- [ ] 정기적 업데이트 계획 수립
+- [ ] 백업 전략 수립
+- [ ] 장애 대응 계획 수립
+
+---
+
+## 🎉 배포 완료!
+
+모든 체크리스트 항목을 완료하면 Lily LLM API가 Hugging Face Spaces에서 성공적으로 실행됩니다.
+
+**다음 단계**: [HEARTH_CHAT_INTEGRATION.md](./HEARTH_CHAT_INTEGRATION.md)를 참조하여 Railway Hearth Chat과 연동을 진행하세요.
+
+---
+
+## 📞 지원
+
+배포 중 문제가 발생하면:
+1. 로그 확인 및 분석
+2. [DEPLOYMENT_GUIDE.md](./DEPLOYMENT_GUIDE.md) 상세 가이드 참조
+3. Hugging Face Community 포럼 활용
+4. GitHub Issues를 통한 기술 지원

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,204 @@
+# Lily LLM API - Hugging Face Spaces 배포 가이드
+
+## 🚀 배포 단계별 가이드
+
+### 1. 사전 준비
+
+#### 1.1 Hugging Face 계정 및 토큰
+1. [Hugging Face](https://huggingface.co) 계정 생성
+2. [Settings > Access Tokens](https://huggingface.co/settings/tokens)에서 Write 권한 토큰 생성
+3. 토큰을 안전한 곳에 저장
+
+#### 1.2 필요한 파일들 확인
+- `Dockerfile.huggingface` - Docker 설정
+- `app_huggingface.py` - 진입점
+- `requirements_full.txt` - 의존성 패키지
+- `README_huggingface.md` - 프로젝트 설명
+- `.dockerignore` - Docker 빌드 제외 파일
+
+### 2. Hugging Face Spaces 생성
+
+#### 2.1 Space 생성
+1. [Hugging Face Spaces](https://huggingface.co/spaces) 접속
+2. "Create new Space" 클릭
+3. 다음 설정으로 Space 생성:
+   - **Owner**: 본인 계정
+   - **Space name**: `lily-llm-api`
+   - **License**: `MIT`
+   - **Select the Space SDK**: `Docker`
+   - **Space hardware**: `CPU basic` (무료) 또는 `CPU upgrade` (유료, 더 빠름)
+   - **Visibility**: `Public` 또는 `Private`
+
+#### 2.2 Space 설정
+Space 생성 후 Settings에서:
+- **Variables**: 필요한 환경 변수 설정
+- **Secrets**: API 키 등 민감한 정보 설정
+
+### 3. 코드 배포
+
+#### 3.1 Git 방식 (권장)
+
+```bash
+# 1. Space 저장소 클론
+git clone https://huggingface.co/spaces/YOUR_USERNAME/lily-llm-api
+cd lily-llm-api
+
+# 2. 필요한 파일들 복사
+cp /path/to/lily_generate_package/Dockerfile.huggingface ./Dockerfile
+cp /path/to/lily_generate_package/app_huggingface.py ./
+cp /path/to/lily_generate_package/requirements_full.txt ./requirements.txt
+cp /path/to/lily_generate_package/README_huggingface.md ./README.md
+cp /path/to/lily_generate_package/.dockerignore ./
+
+# 3. 프로젝트 소스 코드 복사
+cp -r /path/to/lily_generate_package/lily_llm_api ./
+cp -r /path/to/lily_generate_package/lily_llm_core ./
+cp -r /path/to/lily_generate_package/lily_llm_utils ./
+
+# 4. Git 커밋 및 푸시
+git add .
+git commit -m "Initial deployment of Lily LLM API"
+git push
+```
+
+#### 3.2 웹 인터페이스 방식
+
+1. Hugging Face Space 페이지에서 "Files" 탭 클릭
+2. "Add file" > "Upload files" 클릭
+3. 필요한 파일들을 드래그 앤 드롭으로 업로드
+4. 커밋 메시지 작성 후 "Commit changes" 클릭
+
+### 4. 환경 변수 설정
+
+Space Settings > Variables에서 다음 환경 변수들 설정:
+
+```bash
+# 서버 설정
+HOST=0.0.0.0
+PORT=7860
+PYTHONPATH=/app
+PYTHONUNBUFFERED=1
+
+# 모델 설정
+DEFAULT_MODEL=kanana-1.5-v-3b-instruct
+MAX_NEW_TOKENS=256
+TEMPERATURE=0.7
+
+# 캐시 설정
+TRANSFORMERS_CACHE=/app/cache/transformers
+HF_HOME=/app/cache/huggingface
+TORCH_HOME=/app/cache/torch
+TOKENIZERS_PARALLELISM=false
+
+# 성능 최적화
+OMP_NUM_THREADS=1
+MKL_NUM_THREADS=1
+```
+
+### 5. 배포 확인
+
+#### 5.1 빌드 로그 확인
+1. Space 페이지에서 "Logs" 탭 클릭
+2. Docker 빌드 및 실행 로그 확인
+3. 오류 발생 시 로그를 통해 문제 해결
+
+#### 5.2 API 테스트
+
+배포 완료 후 다음과 같이 테스트:
+
+```python
+import requests
+
+# Health check
+response = requests.get("https://YOUR_USERNAME-lily-llm-api.hf.space/health")
+print(response.json())
+
+# 텍스트 생성 테스트
+response = requests.post(
+    "https://YOUR_USERNAME-lily-llm-api.hf.space/generate",
+    data={"prompt": "안녕하세요! 테스트 메시지입니다."}
+)
+print(response.json())
+```
+
+### 6. 성능 최적화
+
+#### 6.1 하드웨어 업그레이드
+- 무료 CPU basic: 제한적 성능
+- 유료 CPU upgrade: 더 빠른 처리
+- GPU 옵션: 대용량 모델 처리 시 필요
+
+#### 6.2 모델 최적화
+```python
+# app_huggingface.py에서 모델 로딩 최적화
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.float16,  # 메모리 사용량 감소
+    device_map="auto",          # 자동 디바이스 배치
+    low_cpu_mem_usage=True      # CPU 메모리 최적화
+)
+```
+
+### 7. 문제 해결
+
+#### 7.1 일반적인 오류
+
+**메모리 부족 오류**
+```bash
+# requirements.txt에서 불필요한 패키지 제거
+# 모델 크기 축소 또는 양자화 적용
+```
+
+**빌드 시간 초과**
+```bash
+# .dockerignore 파일로 불필요한 파일 제외
+# multi-stage build 사용으로 빌드 최적화
+```
+
+**모듈 import 오류**
+```bash
+# PYTHONPATH 환경 변수 확인
+# requirements.txt 의존성 확인
+```
+
+#### 7.2 로그 분석
+```bash
+# 빌드 로그에서 오류 찾기
+grep -i error build.log
+
+# 런타임 로그에서 문제 확인
+tail -f app.log
+```
+
+### 8. Railway Hearth Chat 연동 준비
+
+배포된 Hugging Face Space URL을 기록해두세요:
+```
+https://YOUR_USERNAME-lily-llm-api.hf.space
+```
+
+이 URL을 Hearth Chat의 AI 설정에서 Lily LLM API URL로 사용하게 됩니다.
+
+### 9. 유지보수
+
+#### 9.1 업데이트 배포
+```bash
+# 코드 수정 후
+git add .
+git commit -m "Update: description of changes"
+git push
+```
+
+#### 9.2 모니터링
+- Space 대시보드에서 사용량 모니터링
+- 로그를 통한 오류 추적
+- 성능 메트릭 확인
+
+---
+
+## 📞 지원
+
+배포 중 문제가 발생하면:
+1. Hugging Face 공식 문서 참조
+2. Community 포럼에서 도움 요청
+3. GitHub Issues를 통한 기술 지원

Dockerfile

@@ -0,0 +1,66 @@
+# Hugging Face Spaces용 Lily LLM API Server Dockerfile
+FROM python:3.11-slim
+
+# Hugging Face Spaces 환경 변수
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT=7860
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+ENV TOKENIZERS_PARALLELISM=false
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# 시스템 의존성 설치
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    wget \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libfontconfig1 \
+    libxrender1 \
+    libgl1-mesa-glx \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python 의존성 설치 (캐싱 최적화)
+COPY requirements_full.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# NLTK 데이터 다운로드
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('punkt_tab'); nltk.download('averaged_perceptron_tagger'); nltk.download('maxent_ne_chunker'); nltk.download('words'); nltk.download('stopwords')"
+
+# 애플리케이션 코드 복사
+COPY . .
+
+# 필요한 디렉토리 생성
+RUN mkdir -p /app/data /app/logs /app/models /app/uploads /app/vector_stores /app/temp /app/cache/transformers /app/cache/huggingface
+
+# 권한 설정
+RUN chmod +x /app/*.py
+
+# Hugging Face 캐시 디렉토리 환경 변수 설정
+ENV TRANSFORMERS_CACHE=/app/cache/transformers
+ENV HF_HOME=/app/cache/huggingface
+ENV HF_HUB_CACHE=/app/cache/huggingface
+
+# 환경 감지 설정
+ENV IS_LOCAL=false
+ENV ENVIRONMENT=production
+ENV DOCKER_ENV=server
+
+# Hugging Face Spaces용 앱 시작점 생성
+COPY app_huggingface.py /app/app_huggingface.py
+
+# 포트 노출 (Hugging Face Spaces는 7860 포트 사용)
+EXPOSE 7860
+
+# 헬스체크
+HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# 애플리케이션 실행
+CMD ["python", "app_huggingface.py"]

Dockerfile.blank

@@ -0,0 +1,43 @@
+# Lily LLM API Server Dockerfile
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Download NLTK data
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('punkt_tab'); nltk.download('averaged_perceptron_tagger'); nltk.download('maxent_ne_chunker'); nltk.download('words'); nltk.download('stopwords')"
+
+# Copy application code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p /app/data /app/logs /app/models /app/uploads
+
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+ENV HOST=0.0.0.0
+ENV PORT=8001
+
+# Expose port
+EXPOSE 8001
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8001/health || exit 1
+
+# Run the application
+CMD ["python", "run_server_v2.py"] 

Dockerfile.gpu

@@ -0,0 +1,57 @@
+# GPU 환경을 위한 Dockerfile
+FROM nvidia/cuda:11.8-devel-ubuntu20.04
+
+# 환경 변수 설정
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+ENV CUDA_VISIBLE_DEVICES=0
+
+# 시스템 패키지 업데이트 및 설치
+RUN apt-get update && apt-get install -y \
+    python3.9 \
+    python3.9-dev \
+    python3-pip \
+    git \
+    wget \
+    curl \
+    build-essential \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python 3.9을 기본으로 설정
+RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.9 1
+RUN update-alternatives --install /usr/bin/python python /usr/bin/python3.9 1
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# Python 의존성 파일 복사
+COPY requirements.txt .
+
+# Python 패키지 설치
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# GPU 관련 패키지 설치
+RUN pip3 install --no-cache-dir \
+    torch==2.0.1+cu118 \
+    torchvision==0.15.2+cu118 \
+    torchaudio==2.0.2+cu118 \
+    --index-url https://download.pytorch.org/whl/cu118
+
+# 프로젝트 파일 복사
+COPY . .
+
+# 포트 설정
+EXPOSE 8001
+
+# 헬스체크 추가
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8001/health || exit 1
+
+# 실행 명령
+CMD ["python3", "run_server_v2.py"] 

Dockerfile.huggingface

@@ -0,0 +1,66 @@
+# Hugging Face Spaces용 Lily LLM API Server Dockerfile
+FROM python:3.11-slim
+
+# Hugging Face Spaces 환경 변수
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT=7860
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+ENV TOKENIZERS_PARALLELISM=false
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# 시스템 의존성 설치
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    wget \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libfontconfig1 \
+    libxrender1 \
+    libgl1-mesa-glx \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python 의존성 설치 (캐싱 최적화)
+COPY requirements_full.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# NLTK 데이터 다운로드
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('punkt_tab'); nltk.download('averaged_perceptron_tagger'); nltk.download('maxent_ne_chunker'); nltk.download('words'); nltk.download('stopwords')"
+
+# 애플리케이션 코드 복사
+COPY . .
+
+# 필요한 디렉토리 생성
+RUN mkdir -p /app/data /app/logs /app/models /app/uploads /app/vector_stores /app/temp /app/cache/transformers /app/cache/huggingface
+
+# 권한 설정
+RUN chmod +x /app/*.py
+
+# Hugging Face 캐시 디렉토리 환경 변수 설정
+ENV TRANSFORMERS_CACHE=/app/cache/transformers
+ENV HF_HOME=/app/cache/huggingface
+ENV HF_HUB_CACHE=/app/cache/huggingface
+
+# 환경 감지 설정
+ENV IS_LOCAL=false
+ENV ENVIRONMENT=production
+ENV DOCKER_ENV=server
+
+# Hugging Face Spaces용 앱 시작점 생성
+COPY app_huggingface.py /app/app_huggingface.py
+
+# 포트 노출 (Hugging Face Spaces는 7860 포트 사용)
+EXPOSE 7860
+
+# 헬스체크
+HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# 애플리케이션 실행
+CMD ["python", "app_huggingface.py"]

Dockerfile.huggingface.predownload

@@ -0,0 +1,65 @@
+# Hugging Face Spaces용 Lily LLM API Server Dockerfile (모델 사전 다운로드 버전)
+FROM python:3.11-slim
+
+# Hugging Face Spaces 환경 변수
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT=7860
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+ENV TOKENIZERS_PARALLELISM=false
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# 시스템 의존성 설치
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    wget \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libfontconfig1 \
+    libxrender1 \
+    libgl1-mesa-glx \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python 의존성 설치 (캐싱 최적화)
+COPY requirements_full.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# NLTK 데이터 다운로드
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('punkt_tab'); nltk.download('averaged_perceptron_tagger'); nltk.download('maxent_ne_chunker'); nltk.download('words'); nltk.download('stopwords')"
+
+# 필요한 디렉토리 생성
+RUN mkdir -p /app/data /app/logs /app/models /app/uploads /app/vector_stores /app/temp /app/cache/transformers /app/cache/huggingface
+
+# Hugging Face 캐시 디렉토리 환경 변수 설정
+ENV TRANSFORMERS_CACHE=/app/cache/transformers
+ENV HF_HOME=/app/cache/huggingface
+ENV HF_HUB_CACHE=/app/cache/huggingface
+
+# 모델 다운로드 스크립트 복사 및 실행
+COPY download_model.py /app/download_model.py
+RUN python /app/download_model.py
+
+# 애플리케이션 코드 복사
+COPY . .
+
+# 권한 설정
+RUN chmod +x /app/*.py
+
+# Hugging Face Spaces용 앱 시작점 생성
+COPY app_huggingface.py /app/app_huggingface.py
+
+# 포트 노출 (Hugging Face Spaces는 7860 포트 사용)
+EXPOSE 7860
+
+# 헬스체크
+HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# 애플리케이션 실행
+CMD ["python", "app_huggingface.py"]

Dockerfile.latex-ocr

@@ -0,0 +1,70 @@
+# LaTeX-OCR 전용 컨테이너 (CPU 기반)
+FROM python:3.9-slim
+
+# 환경 변수 설정
+ENV PYTHONUNBUFFERED=1
+ENV DEBIAN_FRONTEND=noninteractive
+
+# 시스템 패키지 설치
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    wget \
+    curl \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# LaTeX-OCR 의존성 설치
+RUN pip install --no-cache-dir \
+    torch==2.0.1 \
+    transformers==4.30.0 \
+    timm==0.6.13 \
+    numpy==1.24.3 \
+    Pillow \
+    requests \
+    faiss-cpu \
+    sentence-transformers \
+    pymupdf \
+    easyocr
+
+# LaTeX-OCR 설치
+RUN pip install --no-cache-dir pix2tex
+
+# 프로젝트 파일 복사
+COPY . .
+
+# LaTeX-OCR 서비스 스크립트 생성
+RUN echo '#!/usr/bin/env python3\n\
+    import sys\n\
+    import os\n\
+    sys.path.insert(0, "/app")\n\
+    \n\
+    from lily_llm_core.latex_ocr_subprocess_v2 import latex_ocr_processor_v2\n\
+    \n\
+    def main():\n\
+    print("LaTeX-OCR 서비스 시작...")\n\
+    processor = latex_ocr_processor_v2\n\
+    print("LaTeX-OCR 서비스 준비 완료")\n\
+    \n\
+    # 서비스 유지\n\
+    import time\n\
+    while True:\n\
+    time.sleep(1)\n\
+    \n\
+    if __name__ == "__main__":\n\
+    main()\n\
+    ' > /app/latex_ocr_service.py
+
+# 실행 권한 부여
+RUN chmod +x /app/latex_ocr_service.py
+
+# 실행 명령
+CMD ["python3", "latex_ocr_service.py"] 

Dockerfile.local

@@ -0,0 +1,54 @@
+# 로컬 개발용 Lily LLM API Server Dockerfile
+FROM python:3.11-slim
+
+# 로컬 환경 변수 설정
+ENV IS_LOCAL=true
+ENV ENVIRONMENT=local
+ENV DOCKER_ENV=local
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+ENV TOKENIZERS_PARALLELISM=false
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# 시스템 의존성 설치
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    wget \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libfontconfig1 \
+    libxrender1 \
+    libgl1-mesa-glx \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python 의존성 설치
+COPY requirements_full.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# NLTK 데이터 다운로드
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('punkt_tab'); nltk.download('averaged_perceptron_tagger'); nltk.download('maxent_ne_chunker'); nltk.download('words'); nltk.download('stopwords')"
+
+# 필요한 디렉토리 생성
+RUN mkdir -p /app/data /app/logs /app/models /app/uploads /app/vector_stores /app/temp
+
+# 애플리케이션 코드 복사
+COPY . .
+
+# 권한 설정
+RUN chmod +x /app/*.py
+
+# 포트 노출 (로컬 개발용)
+EXPOSE 8001
+
+# 헬스체크
+HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:8001/health || exit 1
+
+# 로컬 개발용 앱 시작점
+CMD ["python", "app_local.py"] 

ENVIRONMENT_VARIABLES.md

@@ -0,0 +1,162 @@
+# 🔧 환경 변수 설정 가이드
+
+## 🏠 로컬 개발 환경
+
+### .env 파일 설정
+프로젝트 루트에 `.env` 파일을 생성하고 다음 변수들을 설정하세요:
+
+```bash
+# 기본 서버 설정
+HOST=0.0.0.0
+PORT=8001
+PYTHONPATH=/app
+PYTHONUNBUFFERED=1
+
+# 환경 감지
+IS_LOCAL=true
+ENVIRONMENT=local
+DOCKER_ENV=local
+
+# 모델 설정
+DEFAULT_MODEL=kanana-1.5-v-3b-instruct
+MAX_NEW_TOKENS=256
+TEMPERATURE=0.7
+
+# 로컬 모델 경로 (선택사항)
+LOCAL_MODEL_PATH=./lily_llm_core/models/kanana_1_5_v_3b_instruct
+```
+
+### 로컬 Docker 실행
+```bash
+# 로컬 개발용 Docker 빌드
+docker build -f Dockerfile.local -t lily-llm-local .
+
+# 로컬 실행 (포트 8001)
+docker run -p 8001:8001 --env-file .env lily-llm-local
+```
+
+## ☁️ Hugging Face Spaces 환경
+
+### 필수 환경 변수
+
+Hugging Face Spaces Settings > Variables에서 다음 변수들을 설정하세요:
+
+### 기본 서버 설정
+```bash
+HOST=0.0.0.0
+PORT=7860
+PYTHONPATH=/app
+PYTHONUNBUFFERED=1
+```
+
+### Hugging Face 설정
+```bash
+# 캐시 디렉토리
+TRANSFORMERS_CACHE=/app/cache/transformers
+HF_HOME=/app/cache/huggingface
+HF_HUB_CACHE=/app/cache/huggingface
+
+# 모델 설정
+HF_MODEL_NAME=gbrabbit/lily-math-model
+DEFAULT_MODEL=kanana-1.5-v-3b-instruct
+
+# 토큰화 병렬 처리 비활성화 (메모리 절약)
+TOKENIZERS_PARALLELISM=false
+```
+
+### 성능 최적화
+```bash
+# CPU 스레드 제한 (메모리 절약)
+OMP_NUM_THREADS=1
+MKL_NUM_THREADS=1
+
+# PyTorch 설정
+TORCH_HOME=/app/cache/torch
+PYTORCH_TRANSFORMERS_CACHE=/app/cache/transformers
+```
+
+### AI 모델 설정
+```bash
+# 생성 파라미터
+MAX_NEW_TOKENS=256
+TEMPERATURE=0.7
+TOP_P=0.9
+TOP_K=40
+```
+
+## 선택적 환경 변수
+
+### 디버깅
+```bash
+# 로그 레벨
+LOG_LEVEL=INFO
+DEBUG=false
+
+# 상세 로깅
+TRANSFORMERS_VERBOSITY=warning
+HF_HUB_VERBOSITY=warning
+```
+
+### 보안 (필요시)
+```bash
+# API 키 (필요한 경우)
+HF_TOKEN=your_huggingface_token
+API_SECRET_KEY=your_secret_key
+```
+
+## 🚀 자동 모델 다운로드 동작 방식
+
+### 1단계: 로컬 모델 확인
+- `/app/lily_llm_core/models/kanana_1_5_v_3b_instruct/` 경로 확인
+- 파일이 있으면 로컬 모델 사용
+
+### 2단계: Hugging Face Hub 다운로드
+- 로컬 모델이 없으면 `gbrabbit/lily-math-model`에서 자동 다운로드
+- `/app/cache/transformers/` 경로에 캐시 저장
+
+### 3단계: 모델 로딩
+- 캐시된 모델을 메모리에 로드
+- 서버 시작 완료
+
+## 📊 예상 동작
+
+### 첫 번째 배포
+```
+🌐 Hugging Face Hub에서 다운로드: gbrabbit/lily-math-model
+📥 모델 다운로드 중... (약 2-5분)
+✅ 모델 로드 완료
+🚀 서버 시작: 0.0.0.0:7860
+```
+
+### 이후 재시작
+```
+🗂️ 캐시된 모델 사용: /app/cache/transformers/
+✅ 모델 로드 완료 (약 30초)
+🚀 서버 시작: 0.0.0.0:7860
+```
+
+## 🔍 문제 해결
+
+### 모델 다운로드 실패
+```bash
+# 네트워크 연결 확인
+curl -I https://huggingface.co/gbrabbit/lily-math-model
+
+# Hugging Face Hub 상태 확인
+curl -I https://huggingface.co/api/models/gbrabbit/lily-math-model
+```
+
+### 메모리 부족
+```bash
+# 더 작은 모델 사용 또는 양자화 적용
+# Hardware 업그레이드 고려 (CPU upgrade 또는 GPU)
+```
+
+### 캐시 문제
+```bash
+# 캐시 디렉토리 권한 확인
+ls -la /app/cache/
+
+# 캐시 삭제 후 재시작
+rm -rf /app/cache/transformers/*
+```

GPU_DEPLOYMENT_GUIDE.md

@@ -0,0 +1,240 @@
+# 🚀 GPU 환경 배포 가이드
+
+## 📋 사전 요구사항
+
+### 1. 하드웨어 요구사항
+- **GPU**: NVIDIA GPU (RTX 3060 이상 권장)
+- **메모리**: 최소 16GB RAM, 권장 32GB RAM
+- **저장공간**: 최소 50GB 여유 공간
+
+### 2. 소프트웨어 요구사항
+
+#### NVIDIA 드라이버 설치
+```bash
+# Ubuntu/Debian
+sudo apt update
+sudo apt install nvidia-driver-470
+
+# Windows
+# NVIDIA 웹사이트에서 최신 드라이버 다운로드
+```
+
+#### CUDA 설치
+```bash
+# CUDA 11.8 설치 (권장)
+wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run
+sudo sh cuda_11.8.0_520.61.05_linux.run
+```
+
+#### Docker 설치
+```bash
+# Ubuntu/Debian
+curl -fsSL https://get.docker.com -o get-docker.sh
+sudo sh get-docker.sh
+sudo usermod -aG docker $USER
+
+# Windows
+# Docker Desktop 설치
+```
+
+#### NVIDIA Docker 설치
+```bash
+# NVIDIA Container Toolkit 설치
+distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
+curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
+curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
+
+sudo apt-get update
+sudo apt-get install -y nvidia-docker2
+sudo systemctl restart docker
+```
+
+## 🔧 환경 설정
+
+### 1. GPU 환경 확인
+```bash
+cd C:\Project\lily_generate_project\lily_generate_package
+python check_gpu_environment.py
+```
+
+### 2. Hugging Face 설정
+```bash
+# Hugging Face 토큰 설정
+huggingface-cli login
+
+# 또는 Python 스크립트로 설정
+python huggingface_gpu_setup.py
+```
+
+## 🚀 배포 실행
+
+### 1. 자동 배포 (권장)
+```bash
+# 배포 스크립트 실행
+chmod +x deploy_gpu_huggingface.sh
+./deploy_gpu_huggingface.sh
+```
+
+### 2. 수동 배포
+```bash
+# 1. 기존 컨테이너 정리
+docker-compose -f docker-compose.gpu.yml down --volumes --remove-orphans
+
+# 2. GPU 메모리 정리
+nvidia-smi --gpu-reset
+
+# 3. 이미지 빌드
+docker-compose -f docker-compose.gpu.yml build --no-cache
+
+# 4. 컨테이너 시작
+docker-compose -f docker-compose.gpu.yml up -d
+
+# 5. 서비스 상태 확인
+docker-compose -f docker-compose.gpu.yml logs -f
+```
+
+## 🧪 테스트
+
+### 1. GPU 배포 테스트
+```bash
+python test_gpu_deployment.py
+```
+
+### 2. Hugging Face 모델 테스트
+```bash
+python huggingface_gpu_setup.py
+```
+
+### 3. API 테스트
+```bash
+curl http://localhost:8001/health
+```
+
+## 📊 모니터링
+
+### 1. GPU 사용량 확인
+```bash
+nvidia-smi
+nvidia-smi -l 1  # 1초마다 업데이트
+```
+
+### 2. 컨테이너 상태 확인
+```bash
+docker ps
+docker stats
+```
+
+### 3. 로그 확인
+```bash
+# 전체 로그
+docker-compose -f docker-compose.gpu.yml logs -f
+
+# 특정 서비스 로그
+docker-compose -f docker-compose.gpu.yml logs -f lily-llm-api-gpu
+```
+
+## 🔧 문제 해결
+
+### 1. GPU 메모리 부족
+```bash
+# GPU 메모리 정리
+nvidia-smi --gpu-reset
+
+# 컨테이너 재시작
+docker-compose -f docker-compose.gpu.yml restart
+```
+
+### 2. CUDA 버전 충돌
+```bash
+# CUDA 버전 확인
+nvcc --version
+
+# PyTorch CUDA 버전 확인
+python -c "import torch; print(torch.version.cuda)"
+```
+
+### 3. Docker 권한 문제
+```bash
+# Docker 그룹에 사용자 추가
+sudo usermod -aG docker $USER
+
+# 재로그인 후 확인
+docker ps
+```
+
+### 4. Hugging Face 토큰 문제
+```bash
+# 토큰 재설정
+huggingface-cli logout
+huggingface-cli login
+```
+
+## 📈 성능 최적화
+
+### 1. 메모리 최적화
+```bash
+# 4-bit 양자화 적용
+python huggingface_gpu_setup.py
+
+# 성능 최적화 적용
+python performance_optimization.py
+```
+
+### 2. 배치 크기 조정
+```python
+# config.yaml에서 배치 크기 조정
+batch_size: 4  # GPU 메모리에 따라 조정
+```
+
+### 3. 모델 캐싱
+```bash
+# Hugging Face 캐시 설정
+export HF_HOME="/path/to/cache"
+export TRANSFORMERS_CACHE="/path/to/cache"
+```
+
+## 🔄 업데이트
+
+### 1. 모델 업데이트
+```bash
+# 최신 모델 다운로드
+python huggingface_gpu_setup.py
+
+# 컨테이너 재시작
+docker-compose -f docker-compose.gpu.yml restart
+```
+
+### 2. 코드 업데이트
+```bash
+# 코드 변경 후 재빌드
+docker-compose -f docker-compose.gpu.yml build --no-cache
+docker-compose -f docker-compose.gpu.yml up -d
+```
+
+## 📞 지원
+
+### 문제 발생 시 확인사항
+1. GPU 드라이버 버전
+2. CUDA 버전
+3. Docker 버전
+4. 시스템 메모리 사용량
+5. GPU 메모리 사용량
+
+### 로그 파일 위치
+- Docker 로그: `docker-compose -f docker-compose.gpu.yml logs`
+- 애플리케이션 로그: `logs/` 디렉토리
+- GPU 로그: `nvidia-smi`
+
+## 🎯 성능 벤치마크
+
+### 권장 사양별 성능
+- **RTX 3060 (12GB)**: 기본 모델 실행 가능
+- **RTX 3080 (10GB)**: 중간 크기 모델 실행 가능
+- **RTX 3090 (24GB)**: 대용량 모델 실행 가능
+- **RTX 4090 (24GB)**: 최고 성능, 모든 모델 실행 가능
+
+### 메모��� 사용량 가이드
+- **4-bit 양자화**: 모델 크기의 약 25%
+- **8-bit 양자화**: 모델 크기의 약 50%
+- **16-bit (FP16)**: 모델 크기의 약 100%
+- **32-bit (FP32)**: 모델 크기의 약 200% 

HEARTH_CHAT_INTEGRATION.md

@@ -0,0 +1,382 @@
+# Hearth Chat과 Lily LLM API 연동 가이드
+
+## 🔗 연동 개요
+
+Hugging Face Spaces에 배포된 Lily LLM API를 Railway에서 호스팅되는 Hearth Chat 서비스와 연동하는 방법을 설명합니다.
+
+## 1. Hugging Face Spaces 배포 완료 확인
+
+### 1.1 API 엔드포인트 확인
+배포된 Lily LLM API URL:
+```
+https://YOUR_USERNAME-lily-llm-api.hf.space
+```
+
+### 1.2 주요 엔드포인트 테스트
+
+```bash
+# 헬스 체크
+curl https://YOUR_USERNAME-lily-llm-api.hf.space/health
+
+# 모델 목록 확인
+curl https://YOUR_USERNAME-lily-llm-api.hf.space/models
+
+# 텍스트 생성 테스트
+curl -X POST https://YOUR_USERNAME-lily-llm-api.hf.space/generate \
+  -F "prompt=안녕하세요! 테스트입니다."
+```
+
+## 2. Hearth Chat 설정 업데이트
+
+### 2.1 AI 설정 모달 업데이트
+
+`hearth_chat_react/src/components/AISettingsModal.js`에서 Lily LLM 설정 추가:
+
+```javascript
+// Lily LLM API URL 설정
+{settings.aiProvider === 'lily' && (
+    <>
+        <div className="setting-group">
+            <label className="setting-label">Lily API URL:</label>
+            <input
+                type="url"
+                value={settings.lilyApiUrl}
+                onChange={(e) => handleInputChange('lilyApiUrl', e.target.value)}
+                placeholder="https://your-username-lily-llm-api.hf.space"
+            />
+        </div>
+        
+        <div className="setting-group">
+            <label className="setting-label">Lily 모델:</label>
+            <select
+                value={settings.lilyModel}
+                onChange={(e) => handleInputChange('lilyModel', e.target.value)}
+            >
+                <option value="kanana-1.5-v-3b-instruct">Kanana 1.5 v3B Instruct</option>
+            </select>
+        </div>
+        
+        {/* API 연결 상태 표시 */}
+        <div className="model-info">
+            <small style={{ color: '#4CAF50', fontWeight: 'bold' }}>
+                🌐 Hugging Face Spaces에서 호스팅
+            </small>
+            <small style={{ color: '#666', display: 'block', marginTop: '4px' }}>
+                멀티모달 AI 모델 (텍스트 + 이미지 처리)
+            </small>
+        </div>
+    </>
+)}
+```
+
+### 2.2 연결 테스트 함수 업데이트
+
+```javascript
+case 'lily':
+    testUrl = `${settings.lilyApiUrl}/health`;
+    testData = {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json'
+        }
+    };
+    
+    // 추가 생성 테스트
+    if (response.ok) {
+        const generateTestUrl = `${settings.lilyApiUrl}/generate`;
+        const generateResponse = await fetch(generateTestUrl, {
+            method: 'POST',
+            body: new FormData([
+                ['prompt', '연결 테스트입니다.']
+            ])
+        });
+        
+        if (generateResponse.ok) {
+            const result = await generateResponse.json();
+            console.log('Lily LLM 생성 테스트 성공:', result);
+        }
+    }
+    break;
+```
+
+## 3. 백엔드 연동 업데이트
+
+### 3.1 Consumers.py 수정
+
+`hearth_chat_django/chat/consumers.py`에서 Lily LLM API 호출 부분:
+
+```python
+async def call_lily_api(user_message, user_emotion, image_urls=None, documents=None):
+    """Lily LLM API 호출 (Hugging Face Spaces)"""
+    import requests
+    import aiohttp
+    
+    try:
+        # 사용자 설정에서 API URL 가져오기
+        user = getattr(self, 'scope', {}).get('user', None)
+        ai_settings = None
+        if user and hasattr(user, 'is_authenticated') and user.is_authenticated:
+            ai_settings = await self.get_user_ai_settings(user)
+        
+        # API URL 설정 (기본값: Hugging Face Spaces)
+        lily_api_url = ai_settings.get('lilyApiUrl', 'https://gbrabbit-lily-math-rag.hf.space') if ai_settings else 'https://gbrabbit-lily-math-rag.hf.space'
+        lily_model = ai_settings.get('lilyModel', 'kanana-1.5-v-3b-instruct') if ai_settings else 'kanana-1.5-v-3b-instruct'
+        
+        # API 엔드포인트
+        generate_url = f"{lily_api_url}/generate"
+        
+        # 요청 데이터 준비
+        data = {
+            'prompt': f"{emotion_prompt}\n\n사용자 메시지: {user_message}",
+            'max_length': 200,
+            'temperature': 0.7
+        }
+        
+        files = {}
+        
+        # 이미지 처리
+        if image_urls and len(image_urls) > 0:
+            print(f"🖼️ 이미지 처리: {len(image_urls)}개")
+            
+            async with aiohttp.ClientSession() as session:
+                for i, image_url in enumerate(image_urls[:4]):  # 최대 4개 이미지
+                    try:
+                        async with session.get(image_url) as img_response:
+                            if img_response.status == 200:
+                                image_data = await img_response.read()
+                                files[f'image{i+1}'] = ('image.jpg', image_data, 'image/jpeg')
+                    except Exception as e:
+                        print(f"❌ 이미지 {i+1} 로드 실패: {e}")
+        
+        # API 호출
+        timeout = aiohttp.ClientTimeout(total=120)  # 2분 타임아웃
+        
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            if files:
+                # 멀티파트 요청 (이미지 포함)
+                form_data = aiohttp.FormData()
+                for key, value in data.items():
+                    form_data.add_field(key, str(value))
+                for key, (filename, file_data, content_type) in files.items():
+                    form_data.add_field(key, file_data, filename=filename, content_type=content_type)
+                
+                async with session.post(generate_url, data=form_data) as response:
+                    if response.status == 200:
+                        result = await response.json()
+                        lily_response = result.get('generated_text', '죄송합니다. 응답을 생성할 수 없습니다.')
+                        
+                        return {
+                            "response": lily_response,
+                            "provider": "lily",
+                            "ai_name": "Lily LLM",
+                            "ai_type": "huggingface"
+                        }
+                    else:
+                        error_text = await response.text()
+                        raise Exception(f"Lily API 오류: {response.status} - {error_text}")
+            else:
+                # 일반 POST 요청 (텍스트만)
+                async with session.post(generate_url, data=data) as response:
+                    if response.status == 200:
+                        result = await response.json()
+                        lily_response = result.get('generated_text', '죄송합니다. 응답을 생성할 수 없습니다.')
+                        
+                        return {
+                            "response": lily_response,
+                            "provider": "lily",
+                            "ai_name": "Lily LLM",
+                            "ai_type": "huggingface"
+                        }
+                    else:
+                        error_text = await response.text()
+                        raise Exception(f"Lily API 오류: {response.status} - {error_text}")
+                        
+    except Exception as e:
+        print(f"❌ Lily LLM API 호출 실패: {e}")
+        raise e
+```
+
+### 3.2 환경 변수 설정
+
+Railway 환경에서 다음 환경 변수 추가:
+
+```bash
+# Lily LLM API 설정
+LILY_LLM_API_URL=https://YOUR_USERNAME-lily-llm-api.hf.space
+LILY_LLM_MODEL=kanana-1.5-v-3b-instruct
+LILY_LLM_TIMEOUT=120
+```
+
+## 4. 테스트 및 검증
+
+### 4.1 연동 테스트 스크립트
+
+```python
+# test_hearth_lily_integration.py
+
+import requests
+import json
+
+def test_hearth_chat_lily_integration():
+    """Hearth Chat과 Lily LLM 연동 테스트"""
+    
+    # Hearth Chat API 엔드포인트 (Railway)
+    hearth_chat_url = "https://your-hearth-chat.railway.app"
+    
+    # 1. 로그인 및 세션 획득
+    session = requests.Session()
+    
+    # 2. AI 설정 업데이트
+    ai_settings = {
+        "aiProvider": "lily",
+        "lilyApiUrl": "https://YOUR_USERNAME-lily-llm-api.hf.space",
+        "lilyModel": "kanana-1.5-v-3b-instruct",
+        "aiEnabled": True
+    }
+    
+    settings_response = session.patch(
+        f"{hearth_chat_url}/api/chat/user/settings/",
+        json=ai_settings
+    )
+    
+    print(f"설정 업데이트: {settings_response.status_code}")
+    
+    # 3. 채팅 테스트
+    test_messages = [
+        "안녕하세요! Lily LLM 테스트입니다.",
+        "오늘 날씨가 어떤가요?",
+        "간단한 수학 문제를 내주세요."
+    ]
+    
+    for message in test_messages:
+        print(f"\n📤 테스트 메시지: {message}")
+        
+        # WebSocket 또는 HTTP API를 통한 메시지 전송
+        # (실제 구현에 따라 조정)
+        
+        # 응답 확인
+        print(f"✅ 응답 받음")
+
+if __name__ == "__main__":
+    test_hearth_chat_lily_integration()
+```
+
+### 4.2 이미지 처리 테스트
+
+```python
+def test_image_processing():
+    """이미지 처리 연동 테스트"""
+    
+    # 테스트 이미지 업로드
+    with open("test_image.jpg", "rb") as f:
+        files = {"image": f}
+        data = {"message": "이미지에서 무엇을 볼 수 있나요?"}
+        
+        response = requests.post(
+            "https://your-hearth-chat.railway.app/api/chat/send-message/",
+            files=files,
+            data=data
+        )
+        
+        print(f"이미지 처리 테스트: {response.status_code}")
+        print(f"응답: {response.json()}")
+```
+
+## 5. 모니터링 및 로그
+
+### 5.1 Hugging Face Spaces 로그 모니터링
+
+```bash
+# Spaces 대시보드에서 실시간 로그 확인
+# API 호출 빈도 및 응답 시간 모니터링
+```
+
+### 5.2 Railway 로그 모니터링
+
+```bash
+# Railway 대시보드에서 Hearth Chat 로그 확인
+# Lily LLM API 호출 성공/실패 모니터링
+```
+
+## 6. 성능 최적화
+
+### 6.1 캐싱 전략
+
+```python
+# Redis를 이용한 응답 캐싱
+import redis
+
+redis_client = redis.Redis(host='localhost', port=6379, db=0)
+
+def cached_lily_response(prompt_hash, response):
+    """응답 캐싱"""
+    redis_client.setex(f"lily_cache:{prompt_hash}", 3600, json.dumps(response))
+
+def get_cached_response(prompt_hash):
+    """캐시된 응답 조회"""
+    cached = redis_client.get(f"lily_cache:{prompt_hash}")
+    return json.loads(cached) if cached else None
+```
+
+### 6.2 로드 밸런싱
+
+```python
+# 여러 Hugging Face Spaces 인스턴스 사용
+LILY_API_ENDPOINTS = [
+    "https://username1-lily-llm-api.hf.space",
+    "https://username2-lily-llm-api.hf.space"
+]
+
+def get_available_endpoint():
+    """사용 가능한 엔드포인트 선택"""
+    for endpoint in LILY_API_ENDPOINTS:
+        try:
+            response = requests.get(f"{endpoint}/health", timeout=5)
+            if response.status_code == 200:
+                return endpoint
+        except:
+            continue
+    return LILY_API_ENDPOINTS[0]  # 기본값
+```
+
+## 7. 보안 고려사항
+
+### 7.1 API 키 관리
+
+```python
+# 환경 변수로 민감한 정보 관리
+import os
+
+LILY_API_KEY = os.getenv('LILY_API_KEY')  # 필요시
+LILY_API_SECRET = os.getenv('LILY_API_SECRET')  # 필요시
+```
+
+### 7.2 요청 제한
+
+```python
+# 사용자별 요청 제한
+from django.core.cache import cache
+
+def check_rate_limit(user_id):
+    """사용자별 요청 제한 확인"""
+    key = f"lily_api_rate_limit:{user_id}"
+    current = cache.get(key, 0)
+    
+    if current >= 100:  # 시간당 100회 제한
+        return False
+        
+    cache.set(key, current + 1, 3600)  # 1시간
+    return True
+```
+
+---
+
+## 🎉 연동 완료
+
+모든 설정이 완료되면:
+
+1. **Hugging Face Spaces**: Lily LLM API 서버 호스팅
+2. **Railway**: Hearth Chat 서비스 호스팅  
+3. **연동**: 두 서비스 간 원활한 통신
+
+사용자는 Hearth Chat 인터페이스를 통해 Hugging Face에서 호스팅되는 강력한 Lily LLM AI를 사용할 수 있게 됩니다! 🚀

HISTORY.md

@@ -0,0 +1,191 @@
+# Lily LLM RAG 시스템 개발 히스토리
+
+## 📋 프로젝트 개요
+- **목표**: PDF 문서의 수학 문제 해석 및 해결을 위한 RAG 시스템 구축
+- **환경**: CPU 기반 개발 환경 (GPU 서버 배포 전 테스트)
+- **접근 방식**: 텍스트 기반 RAG → 작은 테스트 데이터로 빠른 검증
+
+## 🔄 주요 작업 흐름
+
+### 1단계: 기존 문제 분석
+- **문제**: Kanana 모델의 멀티모달 처리에서 토큰 ID 응답 문제
+- **원인**: CPU 환경에서 Kanana 모델의 이미지 처리 한계
+- **결정**: 텍스트 기반 RAG로 전환하여 안정성 확보
+
+### 2단계: 텍스트 기반 RAG 시스템 구축
+
+#### 2.1 PDF 텍스트 추출 개선
+**파일**: `lily_llm_core/document_processor.py`
+```python
+# 변경 전: 이미지 기반 OCR 처리
+def process_document(self, file_path: str) -> List[Document]:
+    if self.get_file_type(file_path) == 'pdf':
+        return self._process_pdf_as_images(file_path)  # 이미지 변환
+
+# 변경 후: 텍스트 직접 추출
+def process_document(self, file_path: str) -> List[Document]:
+    # 텍스트 기반 처리 (모든 파일 형식)
+    documents = self.load_document(file_path)
+    split_docs = self.split_documents(documents)
+    return split_docs
+```
+
+#### 2.2 RAG 프로세서 단순화
+**파일**: `lily_llm_core/rag_processor.py`
+```python
+# 멀티모달 처리 제거, 텍스트 기반으로 단순화
+def generate_rag_response(self, user_id: str, document_id: str, query: str, 
+                        llm_model=None, image_files: List[str] = None) -> Dict[str, Any]:
+    # 1. 유사한 문서 검색
+    similar_docs = vector_store_manager.search_similar(
+        user_id, document_id, query, k=self.max_search_results
+    )
+    
+    # 2. 텍스트 기반 응답 생성
+    return self._generate_text_response(query, similar_docs, llm_model, image_files)
+```
+
+#### 2.3 LLM 없이도 작동하는 구조화된 응답
+```python
+def _generate_text_response(self, query: str, text_docs: List[Document], 
+                          llm_model, image_files: List[str] = None) -> Dict[str, Any]:
+    # 컨텍스트 구성 (작은 테스트를 위해 길이 제한)
+    context = self._build_context(text_docs)
+    if len(context) > 2000:
+        context = context[:2000] + "..."
+    
+    # LLM 모델이 있으면 응답 생성, 없으면 컨텍스트만 반환
+    if llm_model:
+        response = self._generate_with_llm_simple(prompt, llm_model)
+    else:
+        # 구조화된 텍스트 응답 생성
+        response = f"""문서에서 검색된 관련 내용을 바탕으로 답변드립니다:
+
+📋 검색된 내용:
+{context}
+
+❓ 질문: {query}
+
+💡 답변: 위 검색된 내용을 참고하여 질문에 대한 답변을 찾아보시기 바랍니다."""
+```
+
+### 3단계: 테스트 시스템 구축
+
+#### 3.1 서버 연결 및 문서 업로드 테스트
+**파일**: `test_simple_rag.py`
+```python
+def test_server_connection():
+    response = requests.get("http://localhost:8001/health", timeout=10)
+    return response.status_code == 200
+
+def test_document_upload():
+    response = requests.post(
+        "http://localhost:8001/document/upload",
+        files=files,
+        data=data,
+        timeout=120
+    )
+```
+
+#### 3.2 텍스트 기반 RAG 테스트
+**파일**: `test_text_only_rag.py`
+```python
+def test_text_only_rag():
+    test_queries = [
+        "1번 문제",
+        "2번 문제", 
+        "3번 문제",
+        "수학 문제"
+    ]
+    
+    for query in test_queries:
+        rag_data = {
+            'user_id': 'test_user',
+            'document_id': document_id,
+            'query': query
+        }
+        response = requests.post(
+            f"{base_url}/rag/generate",
+            data=rag_data,
+            timeout=60
+        )
+```
+
+#### 3.3 구체적인 수학 문제 질문 테스트
+**파일**: `test_specific_questions.py`
+```python
+test_queries = [
+    "23번 문제의 답은 무엇인가요?",
+    "24번 문제를 풀어주세요",
+    "15번 문제의 답을 구해주세요",
+    "23번 문제에서 5개의 문자를 일렬로 나열하는 경우의 수는?",
+    "24번 문제에서 P(B)의 값은?"
+]
+```
+
+### 4단계: 성과 확인
+
+#### 4.1 성공한 기능들
+- ✅ **PDF 텍스트 추출 완벽**: 실제 수학 문제 내용 정확히 추출
+- ✅ **검색 기능 완벽**: 관련 문제들을 정확히 찾아냄
+- ✅ **빠른 처리**: 즉시 응답 (LLM 없이도 작동)
+- ✅ **구조화된 응답**: 문제 분석과 해결 방법 제시
+- ✅ **정확한 문제 매칭**: 23번, 24번, 15번 문제 정확히 찾음
+
+#### 4.2 테스트 결과
+- **문서 업로드**: 12개 청크 성공
+- **검색 결과**: 5개씩 정확히 반환
+- **응답 시간**: 즉시 (토큰 ID 문제 해결됨)
+- **문제 인식**: 실제 수학 문제 내용 정확히 추출
+
+## 🎯 최종 성과
+
+### 해결된 문제들
+1. ✅ **토큰 ID 문제**: 텍스트 기반으로 해결
+2. ✅ **PDF 텍��트 추출**: 실제 문제 내용 추출 성공
+3. ✅ **빠른 검증**: 작은 테스트 데이터로 성공
+4. ✅ **구조화된 응답**: 문제 분석과 해결 방법 포함
+
+### 현재 상태
+**"작은 테스트 데이터로 빠른 검증"** 목표 달성!
+
+- CPU 환경에서도 빠르게 작동
+- 실제 수학 문제 내용 정확히 추출
+- 검색과 컨텍스트 반환 완벽 작동
+- 구조화된 응답 생성
+
+**다음 단계**: 서버에 올려서 GPU로 실사용 준비 완료
+
+## 📁 주요 수정 파일들
+
+### Core 파일들
+- `lily_llm_core/document_processor.py`: PDF 텍스트 추출 개선
+- `lily_llm_core/rag_processor.py`: RAG 프로세서 단순화
+- `lily_llm_api/app_v2.py`: 엔드포인트 수정
+
+### 테스트 파일들
+- `test_simple_rag.py`: 기본 연결 테스트
+- `test_text_only_rag.py`: 텍스트 기반 RAG 테스트
+- `test_specific_questions.py`: 구체적 질문 테스트
+- `test_llm_rag.py`: LLM 포함 테스트
+
+## 🔧 기술적 개선사항
+
+### 1. PDF 처리 방식 변경
+- **이전**: 이미지 기반 OCR → 토큰 ID 문제
+- **현재**: 텍스트 직접 추출 → 안정적 처리
+
+### 2. RAG 프로세서 단순화
+- **이전**: 멀티모달 복잡한 처리
+- **현재**: 텍스트 기반 단순 처리
+
+### 3. 응답 구조 개선
+- **이전**: 토큰 ID 응답
+- **현재**: 구조화된 텍스트 응답
+
+## 🚀 다음 단계 제안
+
+1. **GPU 서버 배포**: 현재 CPU 테스트 완료
+2. **LLM 통합 개선**: 토큰 디코딩 문제 해결
+3. **실제 문제 해결**: 수학 문제 풀이 능력 향상
+4. **성능 최적화**: 더 큰 데이터셋 처리 

HUGGINGFACE_CLOUD_GUIDE.md

@@ -0,0 +1,241 @@
+# ☁️ Hugging Face 클라우드 GPU 배포 가이드
+
+## 📋 개요
+
+이 가이드는 로컬 PC에서 Hugging Face 클라우드 GPU 환경을 설정하고, AI 모델을 배포한 후 Railway에서 실행 중인 Hearth Chat과 연동하는 방법을 설명합니다.
+
+## 🎯 목표
+
+1. **Hugging Face 클라우드 GPU 환경 설정**
+2. **AI 모델을 Hugging Face Hub에 업로드**
+3. **Inference Endpoints 생성**
+4. **Railway Hearth Chat과 연동**
+
+## 🚀 1단계: Hugging Face 계정 설정
+
+### 1.1 Hugging Face 계정 생성
+1. **Hugging Face 웹사이트 방문**: https://huggingface.co
+2. **회원가입**: 이메일로 계정 생성
+3. **프로필 설정**: 사용자명 설정 (예: `your-username`)
+
+### 1.2 Access Token 생성
+1. **Settings > Access Tokens**: https://huggingface.co/settings/tokens
+2. **New Token 생성**: 
+   - Name: `lily-math-rag-token`
+   - Role: `Write`
+3. **토큰 복사**: 생성된 토큰을 안전한 곳에 저장
+
+### 1.3 로컬 환경 설정
+```bash
+# Hugging Face CLI 설치
+pip install huggingface_hub
+
+# 로그인
+huggingface-cli login
+# 토큰 입력 프롬프트에서 위에서 생성한 토큰 입력
+```
+
+## 🔧 2단계: 모델 준비 및 업로드
+
+### 2.1 로컬 모델 확인
+```bash
+cd C:\Project\lily_generate_project\lily_generate_package
+ls hearth_llm_model/
+```
+
+### 2.2 모델을 Hugging Face Hub에 업로드
+```bash
+# 모델 업로드
+huggingface-cli upload your-username/lily-math-model hearth_llm_model/
+
+# 또는 Python 스크립트 사용
+python huggingface_cloud_setup.py
+```
+
+### 2.3 모델 카드 생성
+```markdown
+# 모델 카드 예시 (README.md)
+---
+language: ko
+tags:
+- math
+- rag
+- korean
+license: mit
+---
+
+# Lily Math RAG Model
+
+수학 문제 해결을 위한 한국어 RAG 모델입니다.
+
+## 사용법
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+tokenizer = AutoTokenizer.from_pretrained("your-username/lily-math-model")
+model = AutoModelForCausalLM.from_pretrained("your-username/lily-math-model")
+```
+```
+
+## ☁️ 3단계: Hugging Face Inference Endpoints 설정
+
+### 3.1 Inference Endpoints 생성
+1. **Hugging Face 웹사이트 방문**: https://huggingface.co/inference-endpoints
+2. **New Endpoint 클릭**
+3. **설정 입력**:
+   - **Repository**: `your-username/lily-math-model`
+   - **Framework**: `PyTorch`
+   - **Region**: `us-east-1` (가장 빠름)
+   - **Instance Type**: `gpu.t4.medium` (시작용)
+   - **Accelerator**: `GPU`
+
+### 3.2 엔드포인트 설정
+```json
+{
+  "repository": "your-username/lily-math-model",
+  "framework": "pytorch",
+  "accelerator": "gpu",
+  "instance_type": "gpu.t4.medium",
+  "region": "us-east-1",
+  "vendor": "aws"
+}
+```
+
+### 3.3 엔드포인트 URL 확인
+- 생성된 엔드포인트의 URL을 복사
+- 예: `https://your-endpoint-id.us-east-1.aws.endpoints.huggingface.cloud`
+
+## 🔗 4단계: Railway Hearth Chat 연동
+
+### 4.1 환경 변수 설정
+```bash
+# 환경 변수 설정
+export RAILWAY_HEARTH_CHAT_URL="https://hearth-chat-production.up.railway.app"
+export HF_ENDPOINT_URL="https://your-endpoint-id.us-east-1.aws.endpoints.huggingface.cloud"
+export HF_TOKEN="your-huggingface-token"
+```
+
+### 4.2 연동 테스트
+```bash
+# 연동 테스트 실행
+python railway_hearth_chat_integration.py
+```
+
+### 4.3 Hearth Chat API 수정 (필요시)
+Railway Hearth Chat에서 Hugging Face 엔드포인트를 호출하도록 API를 수정:
+
+```javascript
+// Hearth Chat API 예시
+async function callHuggingFaceAPI(message) {
+  const response = await fetch(process.env.HF_ENDPOINT_URL, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${process.env.HF_TOKEN}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      inputs: message,
+      parameters: {
+        max_length: 200,
+        temperature: 0.7
+      }
+    })
+  });
+  
+  const result = await response.json();
+  return result.generated_text;
+}
+```
+
+## 🧪 5단계: 테스트 및 검증
+
+### 5.1 Hugging Face 엔드포인트 테스트
+```bash
+# 엔드포인트 테스트
+curl -X POST https://your-endpoint-id.us-east-1.aws.endpoints.huggingface.cloud \
+  -H "Authorization: Bearer your-token" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "inputs": "안녕하세요! 수학 문제를 도와주세요.",
+    "parameters": {
+      "max_length": 100,
+      "temperature": 0.7
+    }
+  }'
+```
+
+### 5.2 Railway 연동 테스트
+```bash
+# 전체 연동 테스트
+python test_railway_huggingface_integration.py
+```
+
+## 📊 6단계: 모니터링 및 최적화
+
+### 6.1 Hugging Face 모니터링
+- **Inference Endpoints 대시보드**: https://huggingface.co/inference-endpoints
+- **사용량 확인**: GPU 사용량, 요청 수, 응답 시간
+- **비용 모니터링**: 월별 사용량 및 비용
+
+### 6.2 Railway 모니터링
+- **Railway 대시보드**: https://railway.app/dashboard
+- **로그 확인**: 애플리케이션 로그 및 오류
+- **성능 모니터링**: 응답 시간, 메모리 사용량
+
+## 🔧 문제 해결
+
+### Hugging Face 관련 문제
+1. **토큰 인증 오류**: 토큰 재생성 및 확인
+2. **모델 업로드 실패**: 파일 크기 및 형식 확인
+3. **엔드포인트 생성 실패**: GPU 할당량 확인
+
+### Railway 연동 문제
+1. **연결 실패**: URL 및 네트워크 확인
+2. **API 오류**: 엔드포인트 및 헤더 확인
+3. **응답 지연**: 타임아웃 설정 조정
+
+## 💰 비용 최적화
+
+### Hugging Face 비용
+- **gpu.t4.medium**: $0.60/시간 (시작용)
+- **gpu.t4.large**: $1.20/시간 (성능 향상)
+- **gpu.a10g**: $2.40/시간 (고성능)
+
+### 비용 절약 팁
+1. **자동 스케일링**: 사용하지 않을 때 엔드포인트 중지
+2. **캐싱**: 동일한 요청에 대한 응답 캐싱
+3. **배치 처리**: 여러 요청을 한 번에 처리
+
+## 🚀 배포 체크리스트
+
+- [ ] Hugging Face 계정 생성 및 토큰 설정
+- [ ] 로컬 모델 확인 및 업로드
+- [ ] Inference Endpoints 생성
+- [ ] 엔드포인트 URL 및 토큰 확인
+- [ ] Railway Hearth Chat URL 확인
+- [ ] 환경 변수 설정
+- [ ] 연동 테스트 실행
+- [ ] 모니터링 설정
+- [ ] 비용 최적화 설정
+
+## 📞 지원
+
+### 유용한 링크
+- **Hugging Face 문서**: https://huggingface.co/docs
+- **Inference Endpoints 가이드**: https://huggingface.co/docs/inference-endpoints
+- **Railway 문서**: https://docs.railway.app
+
+### 문제 해결
+1. **Hugging Face 지원**: https://huggingface.co/support
+2. **Railway 지원**: https://railway.app/support
+3. **커뮤니티**: GitHub Issues 및 Discord
+
+## 🎉 성공 확인
+
+모든 설정이 완료되면 다음을 확인할 수 있습니다:
+
+- ✅ **Hugging Face 엔드포인트**: GPU에서 AI 모델 실행
+- ✅ **Railway Hearth Chat**: 웹 인터페이스에서 채팅 가능
+- ✅ **연동**: 사용자 메시지 → Hugging Face → AI 응답 → Hearth Chat
+- ✅ **모니터링**: 실시간 사용량 및 성능 확인 

PROMPT.md

@@ -0,0 +1,105 @@
+# Lily LLM RAG 시스템 개발 - 새 채팅창 AI 프롬프트
+
+## 🎯 프로젝트 목표
+PDF 문서의 수학 문제 해석 및 해결을 위한 RAG 시스템을 구축하고 있습니다. 현재 CPU 환경에서 작은 테스트 데이터로 빠른 검증을 완료했으며, 다음 단계로 GPU 서버 배포 및 실제 문제 해결 능력 향상을 진행해야 합니다.
+
+## 📋 현재 상황
+
+### ✅ 완료된 작업
+1. **텍스트 기반 RAG 시스템 구축**
+   - PDF 텍스트 직접 추출 (이미지 OCR 대신)
+   - RAG 프로세서 단순화 (멀티모달 처리 제거)
+   - LLM 없이도 작동하는 구조화된 응답
+
+2. **테스트 시스템 구축**
+   - 서버 연결 및 문서 업로드 테스트
+   - 텍스트 기반 RAG 쿼리 테스트
+   - 구체적인 수학 문제 질문 테스트
+
+3. **성과 확인**
+   - PDF 텍스트 추출 완벽 작동
+   - 검색 기능 완벽 작동 (5개 검색 결과)
+   - 빠른 처리 (즉시 응답)
+   - 실제 수학 문제 내용 정확히 추출
+
+### 🔧 해결된 문제들
+1. **토큰 ID 문제**: 텍스트 기반으로 해결
+2. **PDF 텍스트 추출**: 실제 문제 내용 추출 성공
+3. **빠른 검증**: 작은 테스트 데이터로 성공
+4. **구조화된 응답**: 문제 분석과 해결 방법 포함
+
+## 📁 주요 파일 구조
+
+### Core 파일들
+- `lily_llm_core/document_processor.py`: PDF 텍스트 추출 개선
+- `lily_llm_core/rag_processor.py`: RAG 프로세서 단순화
+- `lily_llm_api/app_v2.py`: 엔드포인트 수정
+
+### 테스트 파일들
+- `test_simple_rag.py`: 기본 연결 테스트
+- `test_text_only_rag.py`: 텍스트 기반 RAG 테스트
+- `test_specific_questions.py`: 구체적 질문 테스트
+- `test_llm_rag.py`: LLM 포함 테스트
+
+## 🚀 다음 단계 요청사항
+
+### 1. GPU 서버 배포 준비
+- 현재 CPU 환경에서 테스트 완료
+- GPU 환경에서의 성능 최적화
+- 서버 배포 자동화 스크립트 작성
+
+### 2. LLM 통합 개선
+- Kanana 모델의 토큰 디코딩 문제 해결
+- 실제 수학 문제 풀이 능력 향상
+- 더 정확한 답변 생성
+
+### 3. 실제 문제 해결 능력 향상
+- 수학 문제 풀이 로직 개선
+- 단계별 해결 과정 제시
+- 정답과 해설 제공
+
+### 4. 성능 최적화
+- 더 큰 데이터셋 처리
+- 응답 속도 개선
+- 메모리 사용량 최적화
+
+## 💡 기술적 요구사항
+
+### 현재 환경
+- **OS**: Windows 10
+- **Python**: 가상환경 (lily_llm_env)
+- **서버**: FastAPI (포트 8001)
+- **모델**: Kanana-1.5-v-3b-instruct
+- **벡터 스토어**: FAISS
+
+### 목표 환경
+- **GPU 서버**: 더 빠른 처리 속도
+- **확장성**: 더 큰 문서 처리
+- **정확성**: 실제 문제 해결 능력
+
+## 🔍 현재 테스트 결과
+
+### 성공한 기능들
+- ✅ **PDF 텍스트 추출 완벽**: 실제 수학 문제 내용 정확히 추출
+- ✅ **검색 기능 완벽**: 관련 문제들을 정확히 찾아냄
+- ✅ **빠른 처리**: 즉시 응답 (LLM 없이도 작동)
+- ✅ **구조화된 응답**: 문제 분석과 해결 방법 제시
+- ✅ **정확한 문제 매칭**: 23번, 24번, 15번 문제 정확히 찾음
+
+### 테스트 결과
+- **문서 업로드**: 12개 청크 성공
+- **검색 결과**: 5개씩 정확히 반환
+- **응답 시간**: 즉시 (토큰 ID 문제 해결됨)
+- **문제 인식**: 실제 수학 문제 내용 정확히 추출
+
+## 📝 요청사항
+
+새로운 AI 어시스턴트에게 다음 작업을 요청합니다:
+
+1. **현재 코드베이스 분석**: 위에서 언급된 파일들을 검토하여 현재 상태 파악
+2. **GPU 서버 배포 계획 수립**: 현재 CPU 테스트 완료 상태에서 GPU 환경으로 전환
+3. **LLM 통합 개선**: 토큰 디코딩 문제 해결 및 실제 문제 해결 능력 향상
+4. **성능 최적화**: 더 큰 데이터셋 처리 및 응답 속도 개선
+5. **실제 문제 해결**: 수학 문제 풀이 로직 개선 및 정확한 답변 생성
+
+현재 "작은 테스트 데이터로 빠른 검증" 목표는 달성했으므로, 다음 단계인 "실제 문제 해결 능력 향상"과 "GPU 서버 배포"에 집중해주세요. 

README.md

@@ -0,0 +1,137 @@
+# Lily LLM API - Hugging Face Spaces
+
+## 🤖 소개
+
+Lily LLM API는 다중 모델 지원과 RAG(Retrieval Augmented Generation) 시스템을 갖춘 고성능 AI API 서버입니다.
+
+### ✨ 주요 기능
+
+- **🧠 멀티모달 AI**: Kanana-1.5-v-3b-instruct 모델을 통한 텍스트 및 이미지 처리
+- **📚 RAG 시스템**: 문서 기반 질의응답 및 컨텍스트 검색
+- **🔍 벡터 검색**: FAISS 기반 고속 유사도 검색
+- **📄 문서 처리**: PDF, DOCX, TXT 등 다양한 문서 형식 지원
+- **🖼️ 이미지 OCR**: LaTeX-OCR을 통한 수학 공식 인식
+- **⚡ 비동기 처리**: Celery 기반 백그라운드 작업
+- **🌐 RESTful API**: FastAPI 기반 고성능 웹 API
+
+### 🚀 사용 방법
+
+#### 1. 텍스트 생성
+
+```python
+import requests
+
+response = requests.post(
+    "https://huggingface.co/spaces/gbrabbit/lily_fast_api/generate",
+    data={"prompt": "안녕하세요! 오늘 날씨가 어떤가요?"}
+)
+print(response.json())
+```
+
+#### 2. 이미지와 함께 질의
+
+```python
+import requests
+
+with open("image.jpg", "rb") as f:
+    response = requests.post(
+        "https://https://huggingface.co/spaces/gbrabbit/lily_fast_api/generate",
+        data={"prompt": "이미지에서 무엇을 볼 수 있나요?"},
+        files={"image1": f}
+    )
+print(response.json())
+```
+
+#### 3. RAG 기반 질의응답
+
+```python
+import requests
+
+# 문서 업로드
+with open("document.pdf", "rb") as f:
+    upload_response = requests.post(
+        "https://huggingface.co/spaces/gbrabbit/lily_fast_api/upload-document",
+        files={"file": f},
+        data={"user_id": "your_user_id"}
+    )
+
+document_id = upload_response.json()["document_id"]
+
+# RAG 질의
+response = requests.post(
+    "https://huggingface.co/spaces/gbrabbit/lily_fast_api/rag-query",
+    json={
+        "query": "문서의 주요 내용은 무엇인가요?",
+        "user_id": "your_user_id",
+        "document_id": document_id
+    }
+)
+print(response.json())
+```
+
+### 📋 API 엔드포인트
+
+#### 기본 엔드포인트
+- `GET /health` - 서버 상태 확인
+- `GET /models` - 사용 가능한 모델 목록
+- `POST /load-model` - 모델 로드
+- `POST /generate` - 텍스트/이미지 생성
+
+#### RAG 시스템
+- `POST /upload-document` - 문서 업로드
+- `POST /rag-query` - RAG 기반 질의
+- `GET /documents/{user_id}` - 사용자 문서 목록
+- `DELETE /document/{document_id}` - 문서 삭제
+
+#### 고급 기능
+- `POST /batch-process` - 배치 문서 처리
+- `GET /task-status/{task_id}` - 작업 상태 확인
+- `POST /cancel-task/{task_id}` - 작업 취소
+
+### 🛠️ 기술 스택
+
+- **Backend**: FastAPI, Python 3.11
+- **AI Models**: Transformers, PyTorch
+- **Vector DB**: FAISS, ChromaDB
+- **Task Queue**: Celery, Redis
+- **OCR**: LaTeX-OCR, EasyOCR
+- **Document Processing**: LangChain
+
+### 📊 모델 정보
+
+#### Kanana-1.5-v-3b-instruct
+- **크기**: 3.6B 매개변수
+- **언어**: 한국어 특화
+- **기능**: 텍스트 생성, 이미지 이해
+- **컨텍스트**: 최대 4096 토큰
+
+### 🔧 설정
+
+환경 변수를 통해 다음 설정을 조정할 수 있습니다:
+
+```bash
+# 서버 설정
+HOST=0.0.0.0
+PORT=7860
+
+# 모델 설정
+DEFAULT_MODEL=kanana-1.5-v-3b-instruct
+MAX_NEW_TOKENS=256
+TEMPERATURE=0.7
+
+# 캐시 설정
+TRANSFORMERS_CACHE=/app/cache/transformers
+HF_HOME=/app/cache/huggingface
+```
+
+### 📝 라이선스
+
+이 프로젝트는 MIT 라이선스 하에 배포됩니다.
+
+### 🤝 기여
+
+버그 리포트, 기능 제안, 풀 리퀘스트를 환영합니다!
+
+### 📞 지원
+
+문의사항이 있으시면 GitHub Issues를 통해 연락해 주세요.

README_DEPLOYMENT.md

@@ -0,0 +1,304 @@
+# Lily LLM API 배포 가이드
+
+## 📋 개요
+
+이 문서는 Lily LLM API 서버의 Docker 기반 배포 방법을 설명합니다.
+
+## 🏗️ 아키텍처
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Lily LLM API  │    │     Redis       │    │   Celery Worker │
+│   (FastAPI)     │◄──►│   (Message      │◄──►│   (Background   │
+│   Port: 8001    │    │    Broker)      │    │    Tasks)       │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+         ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Flower        │    │   Celery Beat   │    │   Database      │
+│   (Monitoring)  │    │   (Scheduler)   │    │   (SQLite)      │
+│   Port: 5555    │    │                 │    │                 │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+## 🚀 빠른 시작
+
+### 1. 사전 요구사항
+
+- Docker
+- Docker Compose
+- 최소 4GB RAM
+- 최소 10GB 디스크 공간
+
+### 2. 배포 실행
+
+```bash
+# 저장소 클론
+git clone <repository-url>
+cd lily_generate_package
+
+# 배포 스크립트 실행
+chmod +x scripts/deploy.sh
+./scripts/deploy.sh deploy
+```
+
+### 3. 서비스 확인
+
+```bash
+# 서비스 상태 확인
+./scripts/deploy.sh status
+
+# 로그 확인
+./scripts/deploy.sh logs
+```
+
+## 📦 Docker 컨테이너
+
+### 주요 서비스
+
+| 서비스 | 포트 | 설명 |
+|--------|------|------|
+| lily-llm-api | 8001 | FastAPI 메인 서버 |
+| redis | 6379 | 메시지 브로커 및 캐시 |
+| celery-worker | - | 백그라운드 작업 처리 |
+| celery-beat | - | 스케줄러 |
+| flower | 5555 | Celery 모니터링 |
+
+### 환경 변수
+
+```yaml
+# API 서버
+REDIS_URL: redis://redis:6379
+DATABASE_URL: sqlite:///app/data/lily_llm.db
+LOG_LEVEL: INFO
+CELERY_BROKER_URL: redis://redis:6379/0
+CELERY_RESULT_BACKEND: redis://redis:6379/0
+```
+
+## 🔧 배포 스크립트
+
+### 사용 가능한 명령어
+
+```bash
+# 전체 배포
+./scripts/deploy.sh deploy
+
+# 서비스 시작
+./scripts/deploy.sh start
+
+# 서비스 중지
+./scripts/deploy.sh stop
+
+# 서비스 재시작
+./scripts/deploy.sh restart
+
+# 배포 업데이트
+./scripts/deploy.sh update
+
+# 로그 확인
+./scripts/deploy.sh logs
+
+# 상태 확인
+./scripts/deploy.sh status
+
+# 정리
+./scripts/deploy.sh cleanup
+
+# 이미지 빌드
+./scripts/deploy.sh build
+```
+
+## 🧪 테스트
+
+### Docker 배포 테스트
+
+```bash
+python scripts/test_docker_deployment.py
+```
+
+### 수동 테스트
+
+```bash
+# API 상태 확인
+curl http://localhost:8001/health
+
+# 모델 목록 확인
+curl http://localhost:8001/models
+
+# 텍스트 생성 테스트
+curl -X POST http://localhost:8001/generate \
+  -H "Content-Type: application/x-www-form-urlencoded" \
+  -d "prompt=안녕하세요&model_id=polyglot-ko-1.3b-chat&max_length=50"
+```
+
+## 📊 모니터링
+
+### Flower (Celery 모니터링)
+
+- URL: http://localhost:5555
+- 작업 상태, 워커 상태, 성능 메트릭 확인
+
+### API 모니터링
+
+```bash
+# 성능 모니터링 시작
+curl -X POST http://localhost:8001/monitoring/start
+
+# 성능 상태 확인
+curl http://localhost:8001/monitoring/status
+
+# 시스템 건강 상태
+curl http://localhost:8001/monitoring/health
+```
+
+## 🔒 보안
+
+### 환경 변수 관리
+
+```bash
+# .env 파일 생성
+cat > .env << EOF
+SECRET_KEY=your-secret-key-here
+JWT_SECRET_KEY=your-jwt-secret-key
+DATABASE_URL=sqlite:///app/data/lily_llm.db
+REDIS_URL=redis://redis:6379
+EOF
+```
+
+### 방화벽 설정
+
+```bash
+# 필요한 포트만 열기
+sudo ufw allow 8001  # API 서버
+sudo ufw allow 5555  # Flower 모니터링
+```
+
+## 📈 성능 최적화
+
+### 리소스 제한
+
+```yaml
+# docker-compose.yml에 추가
+services:
+  lily-llm-api:
+    deploy:
+      resources:
+        limits:
+          memory: 4G
+          cpus: '2.0'
+        reservations:
+          memory: 2G
+          cpus: '1.0'
+```
+
+### 캐시 설정
+
+```python
+# Redis 캐시 활용
+import redis
+from functools import lru_cache
+
+redis_client = redis.Redis(host='redis', port=6379, db=0)
+
+@lru_cache(maxsize=128)
+def cached_model_response(prompt, model_id):
+    # 캐시된 응답 반환
+    pass
+```
+
+## 🚨 문제 해결
+
+### 일반적인 문제
+
+#### 1. 메��리 부족
+
+```bash
+# 메모리 사용량 확인
+docker stats
+
+# 불필요한 컨테이너 정리
+docker system prune -f
+```
+
+#### 2. API 응답 없음
+
+```bash
+# 컨테이너 상태 확인
+docker-compose ps
+
+# 로그 확인
+docker-compose logs lily-llm-api
+
+# 컨테이너 재시작
+docker-compose restart lily-llm-api
+```
+
+#### 3. Redis 연결 실패
+
+```bash
+# Redis 컨테이너 상태 확인
+docker-compose logs redis
+
+# Redis 재시작
+docker-compose restart redis
+```
+
+### 로그 분석
+
+```bash
+# 실시간 로그 확인
+docker-compose logs -f
+
+# 특정 서비스 로그
+docker-compose logs -f lily-llm-api
+
+# 오류 로그만 확인
+docker-compose logs | grep ERROR
+```
+
+## 🔄 업데이트
+
+### 코드 업데이트
+
+```bash
+# 최신 코드 가져오기
+git pull origin main
+
+# 배포 업데이트
+./scripts/deploy.sh update
+```
+
+### 모델 업데이트
+
+```bash
+# 모델 파일 교체
+cp new_model.safetensors ./models/
+
+# 서비스 재시작
+docker-compose restart lily-llm-api
+```
+
+## 📚 추가 문서
+
+- [API 문서](http://localhost:8001/docs)
+- [성능 가이드](./PERFORMANCE.md)
+- [보안 가이드](./SECURITY.md)
+- [모니터링 가이드](./MONITORING.md)
+
+## 🤝 지원
+
+문제가 발생하면 다음을 확인하세요:
+
+1. 로그 파일 확인
+2. 시스템 리소스 확인
+3. 네트워크 연결 확인
+4. 환경 변수 설정 확인
+
+## 📝 변경 로그
+
+### v1.0.0 (2025-08-04)
+- 초기 Docker 배포 설정
+- CI/CD 파이프라인 구축
+- 모니터링 시스템 추가
+- 보안 설정 강화 

README_LILY.md

@@ -0,0 +1,137 @@
+# Lily LLM API - Hugging Face Spaces
+
+## 🤖 소개
+
+Lily LLM API는 다중 모델 지원과 RAG(Retrieval Augmented Generation) 시스템을 갖춘 고성능 AI API 서버입니다.
+
+### ✨ 주요 기능
+
+- **🧠 멀티모달 AI**: Kanana-1.5-v-3b-instruct 모델을 통한 텍스트 및 이미지 처리
+- **📚 RAG 시스템**: 문서 기반 질의응답 및 컨텍스트 검색
+- **🔍 벡터 검색**: FAISS 기반 고속 유사도 검색
+- **📄 문서 처리**: PDF, DOCX, TXT 등 다양한 문서 형식 지원
+- **🖼️ 이미지 OCR**: LaTeX-OCR을 통한 수학 공식 인식
+- **⚡ 비동기 처리**: Celery 기반 백그라운드 작업
+- **🌐 RESTful API**: FastAPI 기반 고성능 웹 API
+
+### 🚀 사용 방법
+
+#### 1. 텍스트 생성
+
+```python
+import requests
+
+response = requests.post(
+    "https://huggingface.co/spaces/gbrabbit/lily_fast_api/generate",
+    data={"prompt": "안녕하세요! 오늘 날씨가 어떤가요?"}
+)
+print(response.json())
+```
+
+#### 2. 이미지와 함께 질의
+
+```python
+import requests
+
+with open("image.jpg", "rb") as f:
+    response = requests.post(
+        "https://https://huggingface.co/spaces/gbrabbit/lily_fast_api/generate",
+        data={"prompt": "이미지에서 무엇을 볼 수 있나요?"},
+        files={"image1": f}
+    )
+print(response.json())
+```
+
+#### 3. RAG 기반 질의응답
+
+```python
+import requests
+
+# 문서 업로드
+with open("document.pdf", "rb") as f:
+    upload_response = requests.post(
+        "https://huggingface.co/spaces/gbrabbit/lily_fast_api/upload-document",
+        files={"file": f},
+        data={"user_id": "your_user_id"}
+    )
+
+document_id = upload_response.json()["document_id"]
+
+# RAG 질의
+response = requests.post(
+    "https://huggingface.co/spaces/gbrabbit/lily_fast_api/rag-query",
+    json={
+        "query": "문서의 주요 내용은 무엇인가요?",
+        "user_id": "your_user_id",
+        "document_id": document_id
+    }
+)
+print(response.json())
+```
+
+### 📋 API 엔드포인트
+
+#### 기본 엔드포인트
+- `GET /health` - 서버 상태 확인
+- `GET /models` - 사용 가능한 모델 목록
+- `POST /load-model` - 모델 로드
+- `POST /generate` - 텍스트/이미지 생성
+
+#### RAG 시스템
+- `POST /upload-document` - 문서 업로드
+- `POST /rag-query` - RAG 기반 질의
+- `GET /documents/{user_id}` - 사용자 문서 목록
+- `DELETE /document/{document_id}` - 문서 삭제
+
+#### 고급 기능
+- `POST /batch-process` - 배치 문서 처리
+- `GET /task-status/{task_id}` - 작업 상태 확인
+- `POST /cancel-task/{task_id}` - 작업 취소
+
+### 🛠️ 기술 스택
+
+- **Backend**: FastAPI, Python 3.11
+- **AI Models**: Transformers, PyTorch
+- **Vector DB**: FAISS, ChromaDB
+- **Task Queue**: Celery, Redis
+- **OCR**: LaTeX-OCR, EasyOCR
+- **Document Processing**: LangChain
+
+### 📊 모델 정보
+
+#### Kanana-1.5-v-3b-instruct
+- **크기**: 3.6B 매개변수
+- **언어**: 한국어 특화
+- **기능**: 텍스트 생성, 이미지 이해
+- **컨텍스트**: 최대 4096 토큰
+
+### 🔧 설정
+
+환경 변수를 통해 다음 설정을 조정할 수 있습니다:
+
+```bash
+# 서버 설정
+HOST=0.0.0.0
+PORT=7860
+
+# 모델 설정
+DEFAULT_MODEL=kanana-1.5-v-3b-instruct
+MAX_NEW_TOKENS=256
+TEMPERATURE=0.7
+
+# 캐시 설정
+TRANSFORMERS_CACHE=/app/cache/transformers
+HF_HOME=/app/cache/huggingface
+```
+
+### 📝 라이선스
+
+이 프로젝트는 MIT 라이선스 하에 배포됩니다.
+
+### 🤝 기여
+
+버그 리포트, 기능 제안, 풀 리퀘스트를 환영합니다!
+
+### 📞 지원
+
+문의사항이 있으시면 GitHub Issues를 통해 연락해 주세요.

README_gradio.md

@@ -0,0 +1,40 @@
+---
+title: Lily Math RAG System
+emoji: 🧮
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.0.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+test 
+
+# 🧮 Lily Math RAG System
+
+수학 문제 해결을 위한 한국어 AI 시스템입니다.
+
+## 기능
+
+- 💬 **채팅**: 일반적인 대화 및 수학 질문
+- 🧮 **수학 문제 해결**: 구체적인 수학 문제 풀이
+- 🔍 **RAG 기술**: 검색 기반 생성으로 정확한 답변
+
+## 사용법
+
+1. **채팅 탭**: 일반적인 대화나 수학 질문
+2. **수학 문제 해결 탭**: 구체적인 수학 문제 풀이
+3. **설정 탭**: 시스템 정보 확인
+
+## 기술 스택
+
+- **모델**: Polyglot-Ko 5.8B Chat
+- **프레임워크**: Gradio
+- **언어**: 한국어
+- **용도**: 수학 교육 및 문제 해결
+
+## 라이선스
+
+MIT License

README_huggingface.md

@@ -0,0 +1,137 @@
+# Lily LLM API - Hugging Face Spaces
+
+## 🤖 소개
+
+Lily LLM API는 다중 모델 지원과 RAG(Retrieval Augmented Generation) 시스템을 갖춘 고성능 AI API 서버입니다.
+
+### ✨ 주요 기능
+
+- **🧠 멀티모달 AI**: Kanana-1.5-v-3b-instruct 모델을 통한 텍스트 및 이미지 처리
+- **📚 RAG 시스템**: 문서 기반 질의응답 및 컨텍스트 검색
+- **🔍 벡터 검색**: FAISS 기반 고속 유사도 검색
+- **📄 문서 처리**: PDF, DOCX, TXT 등 다양한 문서 형식 지원
+- **🖼️ 이미지 OCR**: LaTeX-OCR을 통한 수학 공식 인식
+- **⚡ 비동기 처리**: Celery 기반 백그라운드 작업
+- **🌐 RESTful API**: FastAPI 기반 고성능 웹 API
+
+### 🚀 사용 방법
+
+#### 1. 텍스트 생성
+
+```python
+import requests
+
+response = requests.post(
+    "https://your-space-url/generate",
+    data={"prompt": "안녕하세요! 오늘 날씨가 어떤가요?"}
+)
+print(response.json())
+```
+
+#### 2. 이미지와 함께 질의
+
+```python
+import requests
+
+with open("image.jpg", "rb") as f:
+    response = requests.post(
+        "https://your-space-url/generate",
+        data={"prompt": "이미지에서 무엇을 볼 수 있나요?"},
+        files={"image1": f}
+    )
+print(response.json())
+```
+
+#### 3. RAG 기반 질의응답
+
+```python
+import requests
+
+# 문서 업로드
+with open("document.pdf", "rb") as f:
+    upload_response = requests.post(
+        "https://your-space-url/upload-document",
+        files={"file": f},
+        data={"user_id": "your_user_id"}
+    )
+
+document_id = upload_response.json()["document_id"]
+
+# RAG 질의
+response = requests.post(
+    "https://your-space-url/rag-query",
+    json={
+        "query": "문서의 주요 내용은 무엇인가요?",
+        "user_id": "your_user_id",
+        "document_id": document_id
+    }
+)
+print(response.json())
+```
+
+### 📋 API 엔드포인트
+
+#### 기본 엔드포인트
+- `GET /health` - 서버 상태 확인
+- `GET /models` - 사용 가능한 모델 목록
+- `POST /load-model` - 모델 로드
+- `POST /generate` - 텍스트/이미지 생성
+
+#### RAG 시스템
+- `POST /upload-document` - 문서 업로드
+- `POST /rag-query` - RAG 기반 질의
+- `GET /documents/{user_id}` - 사용자 문서 목록
+- `DELETE /document/{document_id}` - 문서 삭제
+
+#### 고급 기능
+- `POST /batch-process` - 배치 문서 처리
+- `GET /task-status/{task_id}` - 작업 상태 확인
+- `POST /cancel-task/{task_id}` - 작업 취소
+
+### 🛠️ 기술 스택
+
+- **Backend**: FastAPI, Python 3.11
+- **AI Models**: Transformers, PyTorch
+- **Vector DB**: FAISS, ChromaDB
+- **Task Queue**: Celery, Redis
+- **OCR**: LaTeX-OCR, EasyOCR
+- **Document Processing**: LangChain
+
+### 📊 모델 정보
+
+#### Kanana-1.5-v-3b-instruct
+- **크기**: 3.6B 매개변수
+- **언어**: 한국어 특화
+- **기능**: 텍스트 생성, 이미지 이해
+- **컨텍스트**: 최대 4096 토큰
+
+### 🔧 설정
+
+환경 변수를 통해 다음 설정을 조정할 수 있습니다:
+
+```bash
+# 서버 설정
+HOST=0.0.0.0
+PORT=7860
+
+# 모델 설정
+DEFAULT_MODEL=kanana-1.5-v-3b-instruct
+MAX_NEW_TOKENS=256
+TEMPERATURE=0.7
+
+# 캐시 설정
+TRANSFORMERS_CACHE=/app/cache/transformers
+HF_HOME=/app/cache/huggingface
+```
+
+### 📝 라이선스
+
+이 프로젝트는 MIT 라이선스 하에 배포됩니다.
+
+### 🤝 기여
+
+버그 리포트, 기능 제안, 풀 리퀘스트를 환영합니다!
+
+### 📞 지원
+
+문의사항이 있으시면 GitHub Issues를 통해 연락해 주세요.

WINDOWS_GPU_DEPLOYMENT_GUIDE.md

@@ -0,0 +1,292 @@
+# 🖥️ Windows GPU 환경 배포 가이드
+
+## 📋 사전 요구사항
+
+### 1. 하드웨어 요구사항
+- **GPU**: NVIDIA GPU (RTX 3060 이상 권장)
+- **메모리**: 최소 16GB RAM, 권장 32GB RAM
+- **저장공간**: 최소 50GB 여유 공간
+
+### 2. 소프트웨어 요구사항
+
+#### NVIDIA 드라이버 설치
+1. **NVIDIA 웹사이트 방문**: https://www.nvidia.com/Download/index.aspx
+2. **GPU 모델 선택**: 사용 중인 GPU 모델 선택
+3. **드라이버 다운로드**: 최신 드라이버 다운로드 및 설치
+4. **재부팅**: 설치 완료 후 시스템 재부팅
+
+#### Docker Desktop 설치
+1. **Docker Desktop 다운로드**: https://www.docker.com/products/docker-desktop
+2. **설치 실행**: 다운로드한 파일 실행
+3. **WSL 2 설정**: Windows Subsystem for Linux 2 활성화
+4. **재부팅**: 설치 완료 후 시스템 재부팅
+
+#### Python GPU 라이브러리 설치
+```cmd
+# 가상환경 활성화
+lily_llm_env\Scripts\activate
+
+# PyTorch GPU 버전 설치
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
+
+# Hugging Face 라이브러리 설치
+pip install transformers huggingface_hub
+
+# 추가 GPU 라이브러리 설치
+pip install accelerate bitsandbytes
+```
+
+## 🔧 환경 설정
+
+### 1. GPU 환경 확인
+```cmd
+cd C:\Project\lily_generate_project\lily_generate_package
+python check_gpu_environment.py
+```
+
+### 2. Windows GPU 설정
+```cmd
+# Windows GPU 환경 설정 스크립트 실행
+windows_gpu_setup.bat
+```
+
+### 3. Hugging Face 설정
+```cmd
+# Hugging Face 토큰 설정
+huggingface-cli login
+
+# 또는 Python 스크립트로 설정
+python huggingface_gpu_setup.py
+```
+
+## 🚀 배포 실행
+
+### 1. 자동 배포 (권장)
+```cmd
+# Windows GPU 배포 스크립트 실행
+deploy_gpu_windows.bat
+```
+
+### 2. 수동 배포
+```cmd
+# 1. 기존 컨테이너 정리
+docker-compose -f docker-compose.gpu.yml down --volumes --remove-orphans
+
+# 2. 이미지 빌드
+docker-compose -f docker-compose.gpu.yml build --no-cache
+
+# 3. 컨테이너 시작
+docker-compose -f docker-compose.gpu.yml up -d
+
+# 4. 서비스 상태 확인
+docker-compose -f docker-compose.gpu.yml logs -f
+```
+
+## 🧪 테스트
+
+### 1. GPU 배포 테스트
+```cmd
+python test_gpu_deployment.py
+```
+
+### 2. Hugging Face 모델 테스트
+```cmd
+python huggingface_gpu_setup.py
+```
+
+### 3. API 테스트
+```cmd
+curl http://localhost:8001/health
+```
+
+## 📊 모니터링
+
+### 1. GPU 사용량 확인
+```cmd
+# GPU 정보 확인
+nvidia-smi
+
+# 실시간 모니터링
+nvidia-smi -l 1
+```
+
+### 2. 컨테이너 상태 확인
+```cmd
+# 실행 중인 컨테이너 확인
+docker ps
+
+# 컨테이너 리소스 사용량 확인
+docker stats
+```
+
+### 3. 로그 확인
+```cmd
+# 전체 로그
+docker-compose -f docker-compose.gpu.yml logs -f
+
+# 특정 서비스 로그
+docker-compose -f docker-compose.gpu.yml logs -f lily-llm-api-gpu
+```
+
+## 🔧 문제 해결
+
+### 1. NVIDIA 드라이버 문제
+```cmd
+# 드라이버 버전 확인
+nvidia-smi
+
+# 문제 발생 시 드라이버 재설치
+# 1. 기존 드라이버 제거
+# 2. 최신 드라이버 다운로드 및 설치
+# 3. 시스템 재부팅
+```
+
+### 2. Docker 문제
+```cmd
+# Docker Desktop 재시작
+# Docker Desktop > Settings > General > Restart
+
+# WSL 2 확인
+wsl --list --verbose
+
+# Docker 권한 문제 해결
+# Docker Desktop > Settings > Resources > WSL Integration
+```
+
+### 3. CUDA 버전 충돌
+```cmd
+# PyTorch CUDA 버전 확인
+python -c "import torch; print(torch.version.cuda)"
+
+# CUDA 버전에 맞는 PyTorch 재설치
+pip uninstall torch torchvision torchaudio
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
+```
+
+### 4. 메모리 부족
+```cmd
+# GPU 메모리 확인
+nvidia-smi
+
+# 컨테이너 재시작
+docker-compose -f docker-compose.gpu.yml restart
+
+# 메모리 최적화 적용
+python performance_optimization.py
+```
+
+## 📈 성능 최적화
+
+### 1. Windows 전용 최적화
+```cmd
+# 가상 메모리 증가
+# 제어판 > 시스템 > 고급 시스템 설정 > 성능 > 설정 > 고급 > 가상 메모리
+
+# 전원 설정 최적화
+# 제어판 > 전원 옵션 > 고성능 선택
+```
+
+### 2. Docker 최적화
+```cmd
+# Docker Desktop 설정 최적화
+# Docker Desktop > Settings > Resources
+# - Memory: 8GB 이상 할당
+# - CPUs: 4개 이상 할당
+# - Disk image size: 64GB 이상
+```
+
+### 3. GPU 메모리 최적화
+```python
+# 4-bit 양자화 적용
+python huggingface_gpu_setup.py
+
+# 배치 크기 조정
+# config.yaml에서 batch_size 조정
+```
+
+## 🔄 업데이트
+
+### 1. 모델 업데이트
+```cmd
+# 최신 모델 다운로드
+python huggingface_gpu_setup.py
+
+# 컨테이너 재시작
+docker-compose -f docker-compose.gpu.yml restart
+```
+
+### 2. 코드 업데이트
+```cmd
+# 코드 변경 후 재빌드
+docker-compose -f docker-compose.gpu.yml build --no-cache
+docker-compose -f docker-compose.gpu.yml up -d
+```
+
+## 📞 지원
+
+### 문제 발생 시 확인사항
+1. **GPU 드라이버**: `nvidia-smi` 명령어 실행 가능 여부
+2. **Docker Desktop**: WSL 2 통합 활성화 여부
+3. **CUDA 버전**: PyTorch와 CUDA 버전 호환성
+4. **시스템 메모리**: 16GB 이상 여유 메모리
+5. **GPU 메모리**: 8GB 이상 GPU 메모리
+
+### 로그 파일 위치
+- **Docker 로그**: `docker-compose -f docker-compose.gpu.yml logs`
+- **애플리케이션 로그**: `logs/` 디렉토리
+- **GPU 로그**: `nvidia-smi`
+
+## 🎯 Windows 전용 팁
+
+### 1. WSL 2 최적화
+```cmd
+# WSL 2 메모리 제한 설정
+# %UserProfile%\.wslconfig 파일 생성
+[wsl2]
+memory=8GB
+processors=4
+```
+
+### 2. Windows Defender 예외 설정
+```cmd
+# 프로젝트 폴더를 Windows Defender 예외에 추가
+# Windows 보안 > 바이러스 및 위협 방지 > 설정 > 예외 추가
+```
+
+### 3. 전원 관리 최적화
+```cmd
+# 고성능 전원 계획 선택
+powercfg /setactive 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c
+```
+
+## 🚀 빠른 시작
+
+### 1단계: 환경 확인
+```cmd
+windows_gpu_setup.bat
+```
+
+### 2단계: Hugging Face 설정
+```cmd
+python huggingface_gpu_setup.py
+```
+
+### 3단계: GPU 배포
+```cmd
+deploy_gpu_windows.bat
+```
+
+### 4단계: 테스트
+```cmd
+python test_gpu_deployment.py
+```
+
+## 🎉 성공 확인
+
+배포가 성공적으로 완료되면 다음 서비스들이 실행됩니다:
+
+- ✅ **Lily LLM API**: http://localhost:8001
+- ✅ **Hearth Chat**: http://localhost:8000
+- ✅ **LaTeX-OCR Service**: 별도 컨테이너로 실행
+- ✅ **GPU 가속**: NVIDIA GPU 활용
+- ✅ **Hugging Face 모델**: 최적화된 모델 로드 

__init__.py

@@ -0,0 +1 @@
+# Lily Generate Package yy

app_huggingface.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Spaces용 Lily LLM API 서버 진입점
+"""
+
+import os
+import sys
+import logging
+import asyncio
+import uvicorn
+from pathlib import Path
+
+# 프로젝트 루트를 Python path에 추가
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+# 환경 변수 설정
+os.environ.setdefault("PYTHONPATH", str(project_root))
+os.environ.setdefault("HOST", "0.0.0.0")
+os.environ.setdefault("PORT", "7860")
+
+# 로깅 설정
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+def setup_huggingface_environment():
+    """Hugging Face Spaces 환경 설정"""
+    
+    # 필요한 디렉토리 생성
+    directories = [
+        "data", "logs", "models", "uploads", 
+        "vector_stores", "temp", "cache"
+    ]
+    
+    for dir_name in directories:
+        dir_path = project_root / dir_name
+        dir_path.mkdir(exist_ok=True)
+        logger.info(f"📁 디렉토리 생성: {dir_path}")
+    
+    # 환경 변수 설정
+    env_vars = {
+        "TRANSFORMERS_CACHE": str(project_root / "cache" / "transformers"),
+        "HF_HOME": str(project_root / "cache" / "huggingface"),
+        "TORCH_HOME": str(project_root / "cache" / "torch"),
+        "TOKENIZERS_PARALLELISM": "false",
+        "OMP_NUM_THREADS": "1",
+        "MKL_NUM_THREADS": "1"
+    }
+    
+    for key, value in env_vars.items():
+        os.environ[key] = value
+        logger.info(f"🔧 환경변수 설정: {key}={value}")
+
+async def main():
+    """메인 실행 함수"""
+    
+    logger.info("🚀 Hugging Face Spaces용 Lily LLM API 서버 시작")
+    
+    # 환경 설정
+    setup_huggingface_environment()
+    
+    try:
+        # FastAPI 앱 import
+        from lily_llm_api.app_v2 import app
+        
+        # 서버 설정
+        host = os.getenv("HOST", "0.0.0.0")
+        port = int(os.getenv("PORT", "7860"))
+        
+        logger.info(f"🌐 서버 시작: {host}:{port}")
+        
+        # Uvicorn 서버 실행
+        config = uvicorn.Config(
+            app=app,
+            host=host,
+            port=port,
+            log_level="info",
+            access_log=True,
+            loop="asyncio"
+        )
+        
+        server = uvicorn.Server(config)
+        await server.serve()
+        
+    except Exception as e:
+        logger.error(f"❌ 서버 시작 오류: {e}")
+        import traceback
+        logger.error(f"🔍 상세 오류:\n{traceback.format_exc()}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    # Python 3.7+ 호환성을 위한 asyncio 실행
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("👋 서버 종료")
+    except Exception as e:
+        logger.error(f"❌ 실행 오류: {e}")
+        sys.exit(1)

app_local.py

@@ -0,0 +1,19 @@
+# 로컬 개발용 Lily LLM API Server 시작점
+
+import uvicorn
+from lily_llm_api.app_v2 import app
+import os
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+if __name__ == "__main__":
+    # 로컬 개발 환경 설정
+    host = os.getenv("HOST", "0.0.0.0")
+    port = int(os.getenv("PORT", 8001))
+    
+    logger.info(f"🏠 로컬 개발 서버 시작: {host}:{port}")
+    logger.info("📝 .env 파일에서 환경변수를 로드합니다")
+    
+    uvicorn.run(app, host=host, port=port, reload=True) 

config.yaml

@@ -0,0 +1 @@
+ 

deploy_gpu.sh

@@ -0,0 +1,76 @@
+#!/bin/bash
+
+# GPU 환경 배포 스크립트
+echo "🚀 GPU 환경 배포 시작"
+
+# NVIDIA Docker 지원 확인
+if ! command -v nvidia-docker &> /dev/null; then
+    echo "❌ NVIDIA Docker가 설치되지 않았습니다."
+    echo "NVIDIA Docker 설치가 필요합니다: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html"
+    exit 1
+fi
+
+# GPU 사용 가능 여부 확인
+if ! nvidia-smi &> /dev/null; then
+    echo "❌ GPU를 사용할 수 없습니다."
+    echo "GPU 드라이버가 설치되어 있는지 확인해주세요."
+    exit 1
+fi
+
+echo "✅ GPU 환경 확인 완료"
+
+# 기존 컨테이너 정리
+echo "🧹 기존 컨테이너 정리 중..."
+docker-compose -f docker-compose.gpu.yml down --volumes --remove-orphans
+
+# 이미지 빌드
+echo "🔨 Docker 이미지 빌드 중..."
+docker-compose -f docker-compose.gpu.yml build --no-cache
+
+# 컨테이너 시작
+echo "🚀 컨테이너 시작 중..."
+docker-compose -f docker-compose.gpu.yml up -d
+
+# 서비스 상태 확인
+echo "📊 서비스 상태 확인 중..."
+sleep 10
+
+# 헬스체크
+echo "🏥 헬스체크 중..."
+for i in {1..30}; do
+    if curl -f http://localhost:8001/health &> /dev/null; then
+        echo "✅ Lily LLM API 서비스 정상"
+        break
+    fi
+    
+    if [ $i -eq 30 ]; then
+        echo "❌ 서비스 시작 실패"
+        docker-compose -f docker-compose.gpu.yml logs
+        exit 1
+    fi
+    
+    echo "⏳ 서비스 시작 대기 중... ($i/30)"
+    sleep 2
+done
+
+# GPU 사용량 확인
+echo "🎮 GPU 사용량 확인:"
+nvidia-smi
+
+# 서비스 정보 출력
+echo ""
+echo "🎉 GPU 환경 배포 완료!"
+echo ""
+echo "📋 서비스 정보:"
+echo "  - Lily LLM API: http://localhost:8001"
+echo "  - Hearth Chat: http://localhost:8000"
+echo "  - LaTeX-OCR Service: 별도 컨테이너로 실행 중"
+echo ""
+echo "🔧 유용한 명령어:"
+echo "  - 로그 확인: docker-compose -f docker-compose.gpu.yml logs -f"
+echo "  - 서비스 중지: docker-compose -f docker-compose.gpu.yml down"
+echo "  - 서비스 재시작: docker-compose -f docker-compose.gpu.yml restart"
+echo ""
+echo "🧪 테스트 명령어:"
+echo "  - API 테스트: curl http://localhost:8001/health"
+echo "  - GPU 테스트: python test_gpu_deployment.py" 

deploy_gpu_huggingface.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+
+# Hugging Face GPU 배포 스크립트
+echo "🚀 Hugging Face GPU 환경 배포 시작"
+
+# GPU 환경 확인
+echo "🔍 GPU 환경 확인 중..."
+python check_gpu_environment.py
+
+if [ $? -ne 0 ]; then
+    echo "❌ GPU 환경 확인 실패"
+    exit 1
+fi
+
+# Hugging Face 설정
+echo "🔧 Hugging Face 환경 설정 중..."
+python huggingface_gpu_setup.py
+
+# 기존 컨테이너 정리
+echo "🧹 기존 컨테이너 정리 중..."
+docker-compose -f docker-compose.gpu.yml down --volumes --remove-orphans
+
+# GPU 메모리 정리
+echo "💾 GPU 메모리 정리 중..."
+nvidia-smi --gpu-reset
+
+# 이미지 빌드
+echo "🔨 Docker 이미지 빌드 중..."
+docker-compose -f docker-compose.gpu.yml build --no-cache
+
+# 컨테이너 시작
+echo "🚀 컨테이너 시작 중..."
+docker-compose -f docker-compose.gpu.yml up -d
+
+# 서비스 상태 확인
+echo "📊 서비스 상태 확인 중..."
+sleep 15
+
+# 헬스체크
+echo "🏥 헬스체크 중..."
+for i in {1..30}; do
+    if curl -f http://localhost:8001/health &> /dev/null; then
+        echo "✅ Lily LLM API 서비스 정상"
+        break
+    fi
+    
+    if [ $i -eq 30 ]; then
+        echo "❌ 서비스 시작 실패"
+        docker-compose -f docker-compose.gpu.yml logs
+        exit 1
+    fi
+    
+    echo "⏳ 서비스 시작 대기 중... ($i/30)"
+    sleep 2
+done
+
+# GPU 사용량 확인
+echo "🎮 GPU 사용량 확인:"
+nvidia-smi
+
+# Hugging Face 모델 테스트
+echo "🧪 Hugging Face 모델 테스트 중..."
+python test_gpu_deployment.py
+
+# 성능 최적화 적용
+echo "⚡ 성능 최적화 적용 중..."
+python performance_optimization.py
+
+# 서비스 정보 출력
+echo ""
+echo "🎉 Hugging Face GPU 환경 배포 완료!"
+echo ""
+echo "📋 서비스 정보:"
+echo "  - Lily LLM API: http://localhost:8001"
+echo "  - Hearth Chat: http://localhost:8000"
+echo "  - LaTeX-OCR Service: 별도 컨테이너로 실행 중"
+echo ""
+echo "🔧 유용한 명령어:"
+echo "  - 로그 확인: docker-compose -f docker-compose.gpu.yml logs -f"
+echo "  - 서비스 중지: docker-compose -f docker-compose.gpu.yml down"
+echo "  - 서비스 재시작: docker-compose -f docker-compose.gpu.yml restart"
+echo ""
+echo "🧪 테스트 명령어:"
+echo "  - API 테스트: curl http://localhost:8001/health"
+echo "  - GPU 테스트: python test_gpu_deployment.py"
+echo "  - Hugging Face 테스트: python huggingface_gpu_setup.py"
+echo ""
+echo "💡 Hugging Face 모델 사용:"
+echo "  - 모델 로드: python huggingface_gpu_setup.py"
+echo "  - 토큰 설정: huggingface-cli login" 

deploy_gpu_windows.bat

@@ -0,0 +1,91 @@
+@echo off
+echo 🚀 Windows GPU 환경 배포 시작
+echo ========================================
+
+REM GPU 환경 확인
+echo 🔍 GPU 환경 확인 중...
+python check_gpu_environment.py
+if %errorlevel% neq 0 (
+    echo ❌ GPU 환경 확인 실패
+    echo 💡 GPU 환경을 먼저 설정해주세요
+    pause
+    exit /b 1
+)
+
+REM Hugging Face 설정
+echo 🔧 Hugging Face 환경 설정 중...
+python huggingface_gpu_setup.py
+
+REM 기존 컨테이너 정리
+echo 🧹 기존 컨테이너 정리 중...
+docker-compose -f docker-compose.gpu.yml down --volumes --remove-orphans
+
+REM GPU 메모리 정리 (Windows에서는 제한적)
+echo 💾 GPU 메모리 정리 중...
+REM Windows에서는 nvidia-smi --gpu-reset가 제한적이므로 건너뜀
+
+REM 이미지 빌드
+echo 🔨 Docker 이미지 빌드 중...
+docker-compose -f docker-compose.gpu.yml build --no-cache
+
+REM 컨테이너 시작
+echo 🚀 컨테이너 시작 중...
+docker-compose -f docker-compose.gpu.yml up -d
+
+REM 서비스 상태 확인
+echo 📊 서비스 상태 확인 중...
+timeout /t 15 /nobreak >nul
+
+REM 헬스체크
+echo 🏥 헬스체크 중...
+for /l %%i in (1,1,30) do (
+    curl -f http://localhost:8001/health >nul 2>&1
+    if !errorlevel! equ 0 (
+        echo ✅ Lily LLM API 서비스 정상
+        goto :health_check_passed
+    )
+    echo ⏳ 서비스 시작 대기 중... (%%i/30)
+    timeout /t 2 /nobreak >nul
+)
+echo ❌ 서비스 시작 실패
+docker-compose -f docker-compose.gpu.yml logs
+pause
+exit /b 1
+
+:health_check_passed
+REM GPU 사용량 확인
+echo 🎮 GPU 사용량 확인:
+nvidia-smi 2>nul || echo ⚠️ nvidia-smi를 사용할 수 없습니다
+
+REM Hugging Face 모델 테스트
+echo 🧪 Hugging Face 모델 테스트 중...
+python test_gpu_deployment.py
+
+REM 성능 최적화 적용
+echo ⚡ 성능 최적화 적용 중...
+python performance_optimization.py
+
+REM 서비스 정보 출력
+echo.
+echo 🎉 Windows GPU 환경 배포 완료!
+echo.
+echo 📋 서비스 정보:
+echo   - Lily LLM API: http://localhost:8001
+echo   - Hearth Chat: http://localhost:8000
+echo   - LaTeX-OCR Service: 별도 컨테이너로 실행 중
+echo.
+echo 🔧 유용한 명령어:
+echo   - 로그 확인: docker-compose -f docker-compose.gpu.yml logs -f
+echo   - 서비스 중지: docker-compose -f docker-compose.gpu.yml down
+echo   - 서비스 재시작: docker-compose -f docker-compose.gpu.yml restart
+echo.
+echo 🧪 테스트 명령어:
+echo   - API 테스트: curl http://localhost:8001/health
+echo   - GPU 테스트: python test_gpu_deployment.py
+echo   - Hugging Face 테스트: python huggingface_gpu_setup.py
+echo.
+echo 💡 Hugging Face 모델 사용:
+echo   - 모델 로드: python huggingface_gpu_setup.py
+echo   - 토큰 설정: huggingface-cli login
+echo.
+pause 

docker-compose.gpu.yml

@@ -0,0 +1,66 @@
+version: '3.8'
+
+services:
+  lily-llm-api-gpu:
+    build:
+      context: .
+      dockerfile: Dockerfile.gpu
+    container_name: lily-llm-api-gpu
+    ports:
+      - "8001:8001"
+    volumes:
+      - ./uploads:/app/uploads
+      - ./vector_stores:/app/vector_stores
+      - ./latex_ocr_faiss_stores:/app/latex_ocr_faiss_stores
+      - ./lily_llm_media:/app/lily_llm_media
+      - ./hearth_llm_model:/app/hearth_llm_model
+    environment:
+      - CUDA_VISIBLE_DEVICES=0
+      - PYTHONPATH=/app
+      - LILY_LLM_ENV=production
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [ gpu ]
+    restart: unless-stopped
+    networks:
+      - lily-network
+
+  # LaTeX-OCR 전용 컨테이너 (CPU 기반)
+  latex-ocr-service:
+    build:
+      context: .
+      dockerfile: Dockerfile.latex-ocr
+    container_name: latex-ocr-service
+    volumes:
+      - ./uploads:/app/uploads
+      - ./latex_ocr_faiss_stores:/app/latex_ocr_faiss_stores
+    environment:
+      - PYTHONPATH=/app
+    restart: unless-stopped
+    networks:
+      - lily-network
+
+  # Hearth Chat 서비스 (별도 컨테이너)
+  hearth-chat:
+    image: node:18-alpine
+    container_name: hearth-chat
+    working_dir: /app
+    volumes:
+      - ../hearth_chat_package:/app
+    ports:
+      - "8000:8000"
+    command: [ "npm", "start" ]
+    restart: unless-stopped
+    networks:
+      - lily-network
+
+networks:
+  lily-network:
+    driver: bridge
+
+volumes:
+  lily-data:

docker-compose.yml

@@ -0,0 +1,101 @@
+version: '3.8'
+
+services:
+  # Lily LLM API Server
+  lily-llm-api:
+    build: .
+    container_name: lily-llm-api
+    ports:
+      - "8001:8001"
+    environment:
+      - REDIS_URL=redis://redis:6379
+      - DATABASE_URL=sqlite:///app/data/lily_llm.db
+      - LOG_LEVEL=INFO
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - ./models:/app/models
+      - ./uploads:/app/uploads
+    depends_on:
+      - redis
+    restart: unless-stopped
+    networks:
+      - lily-network
+
+  # Redis for Celery and caching
+  redis:
+    image: redis:7-alpine
+    container_name: lily-redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    restart: unless-stopped
+    networks:
+      - lily-network
+
+  # Celery Worker
+  celery-worker:
+    build: .
+    container_name: lily-celery-worker
+    command: celery -A lily_llm_core.celery_app worker --loglevel=info
+    environment:
+      - REDIS_URL=redis://redis:6379
+      - DATABASE_URL=sqlite:///app/data/lily_llm.db
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - ./models:/app/models
+      - ./uploads:/app/uploads
+    depends_on:
+      - redis
+    restart: unless-stopped
+    networks:
+      - lily-network
+
+  # Celery Beat (Scheduler)
+  celery-beat:
+    build: .
+    container_name: lily-celery-beat
+    command: celery -A lily_llm_core.celery_app beat --loglevel=info
+    environment:
+      - REDIS_URL=redis://redis:6379
+      - DATABASE_URL=sqlite:///app/data/lily_llm.db
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
+    depends_on:
+      - redis
+    restart: unless-stopped
+    networks:
+      - lily-network
+
+  # Flower (Celery Monitoring)
+  flower:
+    build: .
+    container_name: lily-flower
+    command: celery -A lily_llm_core.celery_app flower --port=5555
+    ports:
+      - "5555:5555"
+    environment:
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    depends_on:
+      - redis
+    restart: unless-stopped
+    networks:
+      - lily-network
+
+volumes:
+  redis_data:
+
+
+networks:
+  lily-network:
+    driver: bridge

docs/API_REFERENCE.md

@@ -0,0 +1,507 @@
+# Lily LLM API 참조 문서
+
+## 📋 개요
+
+Lily LLM API는 다양한 언어 모델을 지원하는 RESTful API 서버입니다. 텍스트 생성, 멀티모달 처리, RAG(Retrieval-Augmented Generation) 기능을 제공합니다.
+
+## 🔗 기본 정보
+
+- **Base URL**: `http://localhost:8001`
+- **API 문서**: `http://localhost:8001/docs`
+- **ReDoc 문서**: `http://localhost:8001/redoc`
+
+## 🔐 인증
+
+### JWT 토큰 인증
+
+```bash
+# 로그인
+curl -X POST "http://localhost:8001/auth/login" \
+  -H "Content-Type: application/x-www-form-urlencoded" \
+  -d "username=your_username&password=your_password"
+
+# 응답
+{
+  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+  "refresh_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
+  "token_type": "bearer"
+}
+```
+
+### 보호된 엔드포인트 사용
+
+```bash
+curl -X GET "http://localhost:8001/auth/me" \
+  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"
+```
+
+## 🤖 AI 모델 관련
+
+### 1. 모델 목록 조회
+
+```http
+GET /models
+```
+
+**응답 예시:**
+```json
+{
+  "available_models": [
+    {
+      "model_id": "polyglot-ko-1.3b-chat",
+      "display_name": "Polyglot Korean 1.3B Chat",
+      "model_type": "text",
+      "description": "한국어 특화 텍스트 생성 모델"
+    },
+    {
+      "model_id": "kanana-1.5-v-3b-instruct",
+      "display_name": "Kanana 1.5 v3B Instruct",
+      "model_type": "multimodal",
+      "description": "멀티모달 이미지+텍스트 처리 모델"
+    }
+  ],
+  "current_model": "polyglot-ko-1.3b-chat"
+}
+```
+
+### 2. 텍스트 생성
+
+```http
+POST /generate
+```
+
+**요청 파라미터:**
+```json
+{
+  "prompt": "안녕하세요, AI에 대해 설명해주세요.",
+  "model_id": "polyglot-ko-1.3b-chat",
+  "max_length": 200,
+  "temperature": 0.7,
+  "top_p": 0.9,
+  "do_sample": true
+}
+```
+
+**응답 예시:**
+```json
+{
+  "generated_text": "안녕하세요! AI(인공지능)는 인간의 학습능력과 추론능력을 인공적으로 구현한 컴퓨터 시스템입니다...",
+  "model_name": "polyglot-ko-1.3b-chat",
+  "processing_time": 2.34,
+  "tokens_generated": 45
+}
+```
+
+### 3. 멀티모달 생성 (이미지 + 텍스트)
+
+```http
+POST /generate-multimodal
+```
+
+**요청 (multipart/form-data):**
+```
+prompt: "이 이미지에 대해 설명해주세요"
+model_id: "kanana-1.5-v-3b-instruct"
+max_length: 200
+temperature: 0.7
+image_files: [파일1, 파일2, ...]
+```
+
+**응답 예시:**
+```json
+{
+  "generated_text": "이 이미지는 아름다운 자연 풍경을 보여줍니다...",
+  "model_name": "kanana-1.5-v-3b-instruct",
+  "processing_time": 15.67,
+  "images_processed": 2
+}
+```
+
+## 📄 문서 처리 (RAG)
+
+### 1. 문서 업로드
+
+```http
+POST /document/upload
+```
+
+**요청 (multipart/form-data):**
+```
+file: [PDF/DOC/DOCX/PPTX 파일]
+user_id: "user123"
+```
+
+**응답 예시:**
+```json
+{
+  "document_id": "doc_123456",
+  "filename": "sample.pdf",
+  "file_type": "pdf",
+  "file_size": 1024000,
+  "pages": 15,
+  "chunks": 45,
+  "upload_time": "2025-08-04T10:30:00Z"
+}
+```
+
+### 2. RAG 쿼리
+
+```http
+POST /rag/generate
+```
+
+**요청 파라미터:**
+```json
+{
+  "query": "인공지능의 미래에 대해 알려주세요",
+  "user_id": "user123",
+  "max_length": 300,
+  "temperature": 0.7
+}
+```
+
+**응답 예시:**
+```json
+{
+  "response": "인공지능의 미래는 매우 밝습니다. 현재 문서에 따르면...",
+  "sources": [
+    {
+      "document_id": "doc_123456",
+      "page": 5,
+      "chunk": "AI 기술의 발전 방향..."
+    }
+  ],
+  "confidence": 0.85,
+  "processing_time": 3.45
+}
+```
+
+### 3. 하이브리드 RAG (이미지 + 문서)
+
+```http
+POST /rag/generate-hybrid
+```
+
+**요청 (multipart/form-data):**
+```
+query: "이 이미지와 관련된 문서 내용을 찾아주세요"
+user_id: "user123"
+image_files: [이미지 파일들]
+max_length: 300
+temperature: 0.7
+```
+
+## 💬 채팅 및 세션 관리
+
+### 1. 사용자 생성
+
+```http
+POST /user/create
+```
+
+**요청 파라미터:**
+```json
+{
+  "user_id": "user123",
+  "username": "테스트사용자",
+  "email": "test@example.com"
+}
+```
+
+### 2. 채팅 세션 생성
+
+```http
+POST /session/create
+```
+
+**요청 파라미터:**
+```json
+{
+  "user_id": "user123",
+  "session_name": "AI 상담 세션"
+}
+```
+
+### 3. 메시지 추가
+
+```http
+POST /chat/message
+```
+
+**요청 파라미터:**
+```json
+{
+  "session_id": "session_123",
+  "user_id": "user123",
+  "message_type": "text",
+  "content": "안녕하세요!"
+}
+```
+
+### 4. 채팅 기록 조회
+
+```http
+GET /chat/history/{session_id}
+```
+
+## 🔄 백그라운드 작업
+
+### 1. 문서 처리 작업
+
+```http
+POST /tasks/document/process
+```
+
+**요청 파라미터:**
+```json
+{
+  "file_path": "/uploads/document.pdf",
+  "user_id": "user123"
+}
+```
+
+**응답 예시:**
+```json
+{
+  "task_id": "task_123456",
+  "status": "PENDING",
+  "message": "문서 처리 작업이 시작되었습���다."
+}
+```
+
+### 2. 작업 상태 확인
+
+```http
+GET /tasks/{task_id}
+```
+
+**응답 예시:**
+```json
+{
+  "task_id": "task_123456",
+  "status": "SUCCESS",
+  "result": {
+    "document_id": "doc_123456",
+    "chunks": 45
+  },
+  "progress": 100
+}
+```
+
+## 📊 모니터링
+
+### 1. 성능 모니터링 시작
+
+```http
+POST /monitoring/start
+```
+
+### 2. 성능 상태 조회
+
+```http
+GET /monitoring/status
+```
+
+**응답 예시:**
+```json
+{
+  "current_metrics": {
+    "cpu_percent": 25.5,
+    "memory_percent": 68.2,
+    "memory_used_mb": 8192.0,
+    "disk_usage_percent": 45.0
+  },
+  "performance_stats": {
+    "avg_response_time": 1.23,
+    "avg_inference_time": 2.45,
+    "total_requests": 1250,
+    "success_rate": 98.5
+  },
+  "system_health": {
+    "status": "healthy",
+    "recommendations": []
+  }
+}
+```
+
+### 3. 시스템 건강 상태
+
+```http
+GET /monitoring/health
+```
+
+## 🔌 WebSocket
+
+### 연결
+
+```javascript
+const ws = new WebSocket('ws://localhost:8001/ws/user123');
+
+ws.onopen = function() {
+    console.log('WebSocket 연결됨');
+};
+
+ws.onmessage = function(event) {
+    const data = JSON.parse(event.data);
+    console.log('메시지 수신:', data);
+};
+```
+
+### 메시지 전송
+
+```javascript
+ws.send(JSON.stringify({
+    type: 'chat',
+    message: '안녕하세요!',
+    session_id: 'session_123'
+}));
+```
+
+## 🚨 오류 코드
+
+| 코드 | 의미 | 해결 방법 |
+|------|------|-----------|
+| 400 | 잘못된 요청 | 요청 파라미터 확인 |
+| 401 | 인증 실패 | 토큰 확인 |
+| 403 | 권한 없음 | 권한 확인 |
+| 404 | 리소스 없음 | URL 확인 |
+| 422 | 검증 실패 | 요청 데이터 형식 확인 |
+| 500 | 서버 오류 | 서버 로그 확인 |
+| 503 | 서비스 불가 | 서비스 상태 확인 |
+
+## 📝 예제 코드
+
+### Python 클라이언트
+
+```python
+import requests
+import json
+
+class LilyLLMClient:
+    def __init__(self, base_url="http://localhost:8001"):
+        self.base_url = base_url
+        self.token = None
+    
+    def login(self, username, password):
+        response = requests.post(f"{self.base_url}/auth/login", 
+                               data={"username": username, "password": password})
+        if response.status_code == 200:
+            self.token = response.json()["access_token"]
+            return True
+        return False
+    
+    def generate_text(self, prompt, model_id="polyglot-ko-1.3b-chat"):
+        headers = {"Authorization": f"Bearer {self.token}"} if self.token else {}
+        data = {
+            "prompt": prompt,
+            "model_id": model_id,
+            "max_length": 200,
+            "temperature": 0.7
+        }
+        response = requests.post(f"{self.base_url}/generate", 
+                               data=data, headers=headers)
+        return response.json()
+    
+    def upload_document(self, file_path, user_id):
+        headers = {"Authorization": f"Bearer {self.token}"} if self.token else {}
+        with open(file_path, 'rb') as f:
+            files = {'file': f}
+            data = {'user_id': user_id}
+            response = requests.post(f"{self.base_url}/document/upload", 
+                                   files=files, data=data, headers=headers)
+        return response.json()
+
+# 사용 예제
+client = LilyLLMClient()
+if client.login("username", "password"):
+    result = client.generate_text("안녕하세요!")
+    print(result["generated_text"])
+```
+
+### JavaScript 클라이언트
+
+```javascript
+class LilyLLMClient {
+    constructor(baseUrl = 'http://localhost:8001') {
+        this.baseUrl = baseUrl;
+        this.token = null;
+    }
+    
+    async login(username, password) {
+        const response = await fetch(`${this.baseUrl}/auth/login`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body: `username=${username}&password=${password}`
+        });
+        
+        if (response.ok) {
+            const data = await response.json();
+            this.token = data.access_token;
+            return true;
+        }
+        return false;
+    }
+    
+    async generateText(prompt, modelId = 'polyglot-ko-1.3b-chat') {
+        const headers = this.token ? 
+            {'Authorization': `Bearer ${this.token}`} : {};
+        
+        const formData = new FormData();
+        formData.append('prompt', prompt);
+        formData.append('model_id', modelId);
+        formData.append('max_length', '200');
+        formData.append('temperature', '0.7');
+        
+        const response = await fetch(`${this.baseUrl}/generate`, {
+            method: 'POST',
+            headers,
+            body: formData
+        });
+        
+        return await response.json();
+    }
+}
+
+// 사용 예제
+const client = new LilyLLMClient();
+client.login('username', 'password').then(async (success) => {
+    if (success) {
+        const result = await client.generateText('안녕하세요!');
+        console.log(result.generated_text);
+    }
+});
+```
+
+## 🔧 설정
+
+### 환경 변수
+
+```bash
+# 서버 설정
+HOST=0.0.0.0
+PORT=8001
+LOG_LEVEL=INFO
+
+# 데이터베이스
+DATABASE_URL=sqlite:///app/data/lily_llm.db
+
+# Redis
+REDIS_URL=redis://localhost:6379
+
+# Celery
+CELERY_BROKER_URL=redis://localhost:6379/0
+CELERY_RESULT_BACKEND=redis://localhost:6379/0
+
+# 보안
+SECRET_KEY=your-secret-key
+JWT_SECRET_KEY=your-jwt-secret-key
+```
+
+## 📚 추가 리소스
+
+- [FastAPI 문서](https://fastapi.tiangolo.com/)
+- [Celery 문서](https://docs.celeryproject.org/)
+- [Redis 문서](https://redis.io/documentation)
+- [LangChain 문서](https://python.langchain.com/) 

docs/USER_GUIDE.md

@@ -0,0 +1,719 @@
+# Lily LLM API 사용자 가이드
+
+## 📋 목차
+
+1. [시작하기](#시작하기)
+2. [기본 기능](#기본-기능)
+3. [고급 기능](#고급-기능)
+4. [문제 해결](#문제-해결)
+5. [모범 사례](#모범-사례)
+
+## 🚀 시작하기
+
+### 시스템 요구사항
+
+- **최소 사양**:
+  - CPU: 4코어 이상
+  - RAM: 8GB 이상
+  - 저장공간: 20GB 이상
+  - GPU: 선택사항 (CUDA 지원 시 성능 향상)
+
+- **권장 사양**:
+  - CPU: 8코어 이상
+  - RAM: 16GB 이상
+  - 저장공간: 50GB 이상
+  - GPU: NVIDIA RTX 3060 이상 (CUDA 지원)
+
+### 설치 및 실행
+
+#### 1. Docker를 사용한 배포 (권장)
+
+```bash
+# 저장소 클론
+git clone <repository-url>
+cd lily_generate_package
+
+# 배포 실행
+chmod +x scripts/deploy.sh
+./scripts/deploy.sh deploy
+
+# 상태 확인
+./scripts/deploy.sh status
+```
+
+#### 2. 로컬 개발 환경
+
+```bash
+# 가상환경 생성
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+
+# 의존성 설치
+pip install -r requirements.txt
+
+# NLTK 데이터 다운로드
+python -c "import nltk; nltk.download('punkt'); nltk.download('punkt_tab')"
+
+# 서버 실행
+python run_server_v2.py
+```
+
+### 첫 번째 요청
+
+```bash
+# 서버 상태 확인
+curl http://localhost:8001/health
+
+# 모델 목록 조회
+curl http://localhost:8001/models
+
+# 간단한 텍스트 생성
+curl -X POST http://localhost:8001/generate \
+  -H "Content-Type: application/x-www-form-urlencoded" \
+  -d "prompt=안녕하세요!&model_id=polyglot-ko-1.3b-chat&max_length=100"
+```
+
+## 🤖 기본 기능
+
+### 1. 텍스트 생성
+
+#### 단순 텍스트 생성
+
+```python
+import requests
+
+def generate_text(prompt, model_id="polyglot-ko-1.3b-chat"):
+    url = "http://localhost:8001/generate"
+    data = {
+        "prompt": prompt,
+        "model_id": model_id,
+        "max_length": 200,
+        "temperature": 0.7,
+        "top_p": 0.9,
+        "do_sample": True
+    }
+    
+    response = requests.post(url, data=data)
+    return response.json()
+
+# 사용 예제
+result = generate_text("인공지능의 미래에 대해 설명해주세요.")
+print(result["generated_text"])
+```
+
+#### 파라미터 설명
+
+| 파라미터 | 설명 | 기본값 | 범위 |
+|----------|------|--------|------|
+| `prompt` | 입력 텍스트 | 필수 | - |
+| `model_id` | 사용할 모델 | polyglot-ko-1.3b-chat | 사용 가능한 모델 목록 |
+| `max_length` | 최대 토큰 수 | 200 | 1-4000 |
+| `temperature` | 창의성 조절 | 0.7 | 0.0-2.0 |
+| `top_p` | 누적 확률 임계값 | 0.9 | 0.0-1.0 |
+| `do_sample` | 샘플링 사용 여부 | True | True/False |
+
+### 2. 멀티모달 처리
+
+#### 이미지와 텍스트 함께 처리
+
+```python
+def generate_multimodal(prompt, image_files, model_id="kanana-1.5-v-3b-instruct"):
+    url = "http://localhost:8001/generate-multimodal"
+    
+    files = []
+    for i, image_file in enumerate(image_files):
+        files.append(('image_files', (f'image_{i}.jpg', open(image_file, 'rb'), 'image/jpeg')))
+    
+    data = {
+        "prompt": prompt,
+        "model_id": model_id,
+        "max_length": 200,
+        "temperature": 0.7
+    }
+    
+    response = requests.post(url, files=files, data=data)
+    return response.json()
+
+# 사용 예제
+result = generate_multimodal(
+    "이 이미지에 대해 설명해주세요.",
+    ["image1.jpg", "image2.jpg"]
+)
+print(result["generated_text"])
+```
+
+### 3. 사용자 관리
+
+#### 사용자 등록 및 로그인
+
+```python
+def register_user(username, email, password):
+    url = "http://localhost:8001/auth/register"
+    data = {
+        "username": username,
+        "email": email,
+        "password": password
+    }
+    
+    response = requests.post(url, data=data)
+    return response.json()
+
+def login_user(username, password):
+    url = "http://localhost:8001/auth/login"
+    data = {
+        "username": username,
+        "password": password
+    }
+    
+    response = requests.post(url, data=data)
+    return response.json()
+
+# 사용 예제
+# 1. 사용자 등록
+register_result = register_user("testuser", "test@example.com", "password123")
+access_token = register_result["access_token"]
+
+# 2. 로그인
+login_result = login_user("testuser", "password123")
+access_token = login_result["access_token"]
+```
+
+#### 인증이 필요한 요청
+
+```python
+def authenticated_request(url, data, token):
+    headers = {"Authorization": f"Bearer {token}"}
+    response = requests.post(url, data=data, headers=headers)
+    return response.json()
+
+# 사용 예제
+result = authenticated_request(
+    "http://localhost:8001/generate",
+    {"prompt": "안녕하세요!", "model_id": "polyglot-ko-1.3b-chat"},
+    access_token
+)
+```
+
+## 📄 고급 기능
+
+### 1. 문서 처리 (RAG)
+
+#### 문서 업로드
+
+```python
+def upload_document(file_path, user_id, token=None):
+    url = "http://localhost:8001/document/upload"
+    
+    with open(file_path, 'rb') as f:
+        files = {'file': f}
+        data = {'user_id': user_id}
+        headers = {"Authorization": f"Bearer {token}"} if token else {}
+        
+        response = requests.post(url, files=files, data=data, headers=headers)
+        return response.json()
+
+# 사용 예제
+result = upload_document("document.pdf", "user123", access_token)
+document_id = result["document_id"]
+```
+
+#### RAG 쿼리
+
+```python
+def rag_query(query, user_id, token=None):
+    url = "http://localhost:8001/rag/generate"
+    
+    data = {
+        "query": query,
+        "user_id": user_id,
+        "max_length": 300,
+        "temperature": 0.7
+    }
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    
+    response = requests.post(url, data=data, headers=headers)
+    return response.json()
+
+# 사용 예제
+result = rag_query("인공지능의 미래에 대해 알려주세요.", "user123", access_token)
+print(result["response"])
+print("출처:", result["sources"])
+```
+
+#### 하이브리드 RAG (이미지 + 문서)
+
+```python
+def hybrid_rag_query(query, image_files, user_id, token=None):
+    url = "http://localhost:8001/rag/generate-hybrid"
+    
+    files = []
+    for i, image_file in enumerate(image_files):
+        files.append(('image_files', (f'image_{i}.jpg', open(image_file, 'rb'), 'image/jpeg')))
+    
+    data = {
+        "query": query,
+        "user_id": user_id,
+        "max_length": 300,
+        "temperature": 0.7
+    }
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    
+    response = requests.post(url, files=files, data=data, headers=headers)
+    return response.json()
+```
+
+### 2. 채팅 세션 관리
+
+#### 세션 생성 및 메시지 관리
+
+```python
+def create_chat_session(user_id, session_name, token=None):
+    url = "http://localhost:8001/session/create"
+    
+    data = {
+        "user_id": user_id,
+        "session_name": session_name
+    }
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    
+    response = requests.post(url, data=data, headers=headers)
+    return response.json()
+
+def add_chat_message(session_id, user_id, content, token=None):
+    url = "http://localhost:8001/chat/message"
+    
+    data = {
+        "session_id": session_id,
+        "user_id": user_id,
+        "message_type": "text",
+        "content": content
+    }
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    
+    response = requests.post(url, data=data, headers=headers)
+    return response.json()
+
+def get_chat_history(session_id, token=None):
+    url = f"http://localhost:8001/chat/history/{session_id}"
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    
+    response = requests.get(url, headers=headers)
+    return response.json()
+
+# 사용 예제
+# 1. 세션 생성
+session_result = create_chat_session("user123", "AI 상담", access_token)
+session_id = session_result["session_id"]
+
+# 2. 메시지 추가
+add_chat_message(session_id, "user123", "안녕하세요!", access_token)
+
+# 3. 채팅 기록 조회
+history = get_chat_history(session_id, access_token)
+for message in history:
+    print(f"{message['timestamp']}: {message['content']}")
+```
+
+### 3. 백그라운드 작업
+
+#### 문서 처리 작업
+
+```python
+def start_document_processing(file_path, user_id, token=None):
+    url = "http://localhost:8001/tasks/document/process"
+    
+    data = {
+        "file_path": file_path,
+        "user_id": user_id
+    }
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    
+    response = requests.post(url, data=data, headers=headers)
+    return response.json()
+
+def check_task_status(task_id, token=None):
+    url = f"http://localhost:8001/tasks/{task_id}"
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    
+    response = requests.get(url, headers=headers)
+    return response.json()
+
+# 사용 예제
+# 1. 작업 시작
+task_result = start_document_processing("/path/to/document.pdf", "user123", access_token)
+task_id = task_result["task_id"]
+
+# 2. 작업 상태 확인
+import time
+while True:
+    status = check_task_status(task_id, access_token)
+    print(f"상태: {status['status']}, 진행률: {status.get('progress', 0)}%")
+    
+    if status['status'] in ['SUCCESS', 'FAILURE']:
+        break
+    
+    time.sleep(5)
+```
+
+### 4. 모니터링
+
+#### 성능 모니터링
+
+```python
+def start_monitoring():
+    url = "http://localhost:8001/monitoring/start"
+    response = requests.post(url)
+    return response.json()
+
+def get_monitoring_status():
+    url = "http://localhost:8001/monitoring/status"
+    response = requests.get(url)
+    return response.json()
+
+def get_system_health():
+    url = "http://localhost:8001/monitoring/health"
+    response = requests.get(url)
+    return response.json()
+
+# 사용 예제
+# 1. 모니터링 시작
+start_monitoring()
+
+# 2. 상태 확인
+status = get_monitoring_status()
+print(f"CPU 사용률: {status['current_metrics']['cpu_percent']}%")
+print(f"메모리 사용률: {status['current_metrics']['memory_percent']}%")
+
+# 3. 시스템 건강 상태
+health = get_system_health()
+print(f"시스템 상태: {health['status']}")
+for recommendation in health['recommendations']:
+    print(f"권장사항: {recommendation}")
+```
+
+## 🔌 WebSocket 실시간 채팅
+
+### WebSocket 클라이언트
+
+```javascript
+class LilyLLMWebSocket {
+    constructor(userId) {
+        this.userId = userId;
+        this.ws = null;
+        this.messageHandlers = [];
+    }
+    
+    connect() {
+        this.ws = new WebSocket(`ws://localhost:8001/ws/${this.userId}`);
+        
+        this.ws.onopen = () => {
+            console.log('WebSocket 연결됨');
+        };
+        
+        this.ws.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            this.handleMessage(data);
+        };
+        
+        this.ws.onclose = () => {
+            console.log('WebSocket 연결 종료');
+        };
+        
+        this.ws.onerror = (error) => {
+            console.error('WebSocket 오류:', error);
+        };
+    }
+    
+    sendMessage(message, sessionId) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: 'chat',
+                message: message,
+                session_id: sessionId
+            }));
+        }
+    }
+    
+    addMessageHandler(handler) {
+        this.messageHandlers.push(handler);
+    }
+    
+    handleMessage(data) {
+        this.messageHandlers.forEach(handler => handler(data));
+    }
+    
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+        }
+    }
+}
+
+// 사용 예제
+const wsClient = new LilyLLMWebSocket('user123');
+wsClient.connect();
+
+wsClient.addMessageHandler((data) => {
+    console.log('메시지 수신:', data);
+});
+
+wsClient.sendMessage('안녕하세요!', 'session123');
+```
+
+## 🚨 문제 해결
+
+### 일반적인 문제들
+
+#### 1. 서버 연결 실패
+
+**증상**: `Connection refused` 또는 `Failed to establish a new connection`
+
+**해결 방법**:
+```bash
+# 서버 상태 확인
+curl http://localhost:8001/health
+
+# 서버 재시작
+./scripts/deploy.sh restart
+
+# 로그 확인
+./scripts/deploy.sh logs
+```
+
+#### 2. 메모리 부족
+
+**증상**: `Out of memory` 또는 응답 속도 저하
+
+**해결 방법**:
+```bash
+# 메모리 사용량 확인
+docker stats
+
+# 불필요한 컨테이너 정리
+docker system prune -f
+
+# 리소스 제한 설정 (docker-compose.yml)
+services:
+  lily-llm-api:
+    deploy:
+      resources:
+        limits:
+          memory: 4G
+```
+
+#### 3. 모델 로딩 실패
+
+**증상**: `Model not found` 또는 모델 관련 오류
+
+**해결 방법**:
+```bash
+# 모델 목록 확인
+curl http://localhost:8001/models
+
+# 모델 파일 확인
+ls -la models/
+
+# 서버 재시작
+./scripts/deploy.sh restart
+```
+
+#### 4. 인증 오류
+
+**증상**: `401 Unauthorized` 또는 `403 Forbidden`
+
+**해결 방법**:
+```python
+# 토큰 갱신
+def refresh_token(refresh_token):
+    url = "http://localhost:8001/auth/refresh"
+    data = {"refresh_token": refresh_token}
+    response = requests.post(url, data=data)
+    return response.json()
+
+# 새로운 토큰으로 요청
+new_tokens = refresh_token(old_refresh_token)
+access_token = new_tokens["access_token"]
+```
+
+### 성능 최적화
+
+#### 1. 배치 처리
+
+```python
+def batch_generate_texts(prompts, model_id="polyglot-ko-1.3b-chat"):
+    results = []
+    for prompt in prompts:
+        result = generate_text(prompt, model_id)
+        results.append(result)
+    return results
+
+# 사용 예제
+prompts = [
+    "첫 번째 질문입니다.",
+    "두 번째 질문입니다.",
+    "세 번째 질문입니다."
+]
+results = batch_generate_texts(prompts)
+```
+
+#### 2. 캐싱 활용
+
+```python
+import redis
+import json
+
+class CachedLilyLLMClient:
+    def __init__(self, base_url="http://localhost:8001"):
+        self.base_url = base_url
+        self.redis_client = redis.Redis(host='localhost', port=6379, db=0)
+    
+    def generate_text_with_cache(self, prompt, model_id="polyglot-ko-1.3b-chat"):
+        # 캐시 키 생성
+        cache_key = f"text_gen:{hash(prompt + model_id)}"
+        
+        # 캐시에서 확인
+        cached_result = self.redis_client.get(cache_key)
+        if cached_result:
+            return json.loads(cached_result)
+        
+        # API 호출
+        result = generate_text(prompt, model_id)
+        
+        # 캐시에 저장 (1시간)
+        self.redis_client.setex(cache_key, 3600, json.dumps(result))
+        
+        return result
+```
+
+## 📚 모범 사례
+
+### 1. 에러 처리
+
+```python
+import requests
+from requests.exceptions import RequestException
+
+def safe_api_call(func, *args, **kwargs):
+    try:
+        return func(*args, **kwargs)
+    except RequestException as e:
+        print(f"네트워크 오류: {e}")
+        return None
+    except Exception as e:
+        print(f"예상치 못한 오류: {e}")
+        return None
+
+# 사용 예제
+result = safe_api_call(generate_text, "안녕하세요!")
+if result:
+    print(result["generated_text"])
+```
+
+### 2. 재시도 로직
+
+```python
+import time
+from functools import wraps
+
+def retry_on_failure(max_retries=3, delay=1):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    if attempt == max_retries - 1:
+                        raise e
+                    print(f"시도 {attempt + 1} 실패, {delay}초 후 재시도...")
+                    time.sleep(delay)
+            return None
+        return wrapper
+    return decorator
+
+# 사용 예제
+@retry_on_failure(max_retries=3, delay=2)
+def robust_generate_text(prompt):
+    return generate_text(prompt)
+```
+
+### 3. 비동기 처리
+
+```python
+import asyncio
+import aiohttp
+
+async def async_generate_text(session, prompt, model_id="polyglot-ko-1.3b-chat"):
+    url = "http://localhost:8001/generate"
+    data = {
+        "prompt": prompt,
+        "model_id": model_id,
+        "max_length": 200,
+        "temperature": 0.7
+    }
+    
+    async with session.post(url, data=data) as response:
+        return await response.json()
+
+async def batch_generate_async(prompts):
+    async with aiohttp.ClientSession() as session:
+        tasks = [async_generate_text(session, prompt) for prompt in prompts]
+        results = await asyncio.gather(*tasks)
+        return results
+
+# 사용 예제
+prompts = ["질문1", "질문2", "질문3"]
+results = asyncio.run(batch_generate_async(prompts))
+```
+
+### 4. 로깅
+
+```python
+import logging
+
+# 로깅 설정
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('lily_llm_client.log'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+def generate_text_with_logging(prompt, model_id="polyglot-ko-1.3b-chat"):
+    logger.info(f"텍스트 생성 시작: {prompt[:50]}...")
+    
+    try:
+        result = generate_text(prompt, model_id)
+        logger.info(f"텍스트 생성 성공: {len(result['generated_text'])} 문자")
+        return result
+    except Exception as e:
+        logger.error(f"텍스트 생성 실패: {e}")
+        raise
+```
+
+## 📞 지원
+
+### 도움말 리소스
+
+- **API 문서**: `http://localhost:8001/docs`
+- **ReDoc 문서**: `http://localhost:8001/redoc`
+- **GitHub Issues**: 프로젝트 저장소의 Issues 섹션
+- **로그 파일**: `./logs/` 디렉토리
+
+### 디버깅 팁
+
+1. **로그 확인**: 항상 로그를 먼저 확인하세요
+2. **단계별 테스트**: 복잡한 요청을 작은 단위로 나누어 테스트하세요
+3. **네트워크 확인**: 방화벽이나 프록시 설정을 확인하세요
+4. **리소스 모니터링**: CPU, 메모리, 디스크 사용량을 주기적으로 확인하세요
+
+### 성능 팁
+
+1. **적절한 모델 선택**: 작업에 맞는 모델을 선택하세요
+2. **배치 처리**: 여러 요청을 한 번에 처리하세요
+3. **캐싱 활용**: 반복되는 요청은 캐시를 사용하세요
+4. **비동기 처리**: 대량의 요청은 비동기로 처리하세요 

download_model.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""
+Docker 빌드 시 Hugging Face 모델 다운로드 스크립트
+"""
+
+import os
+import logging
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def download_model():
+    """Hugging Face Hub에서 모델 다운로드"""
+    
+    model_name = "gbrabbit/lily-math-model"
+    cache_dir = "/app/cache/transformers"
+    
+    logger.info(f"📥 모델 다운로드 시작: {model_name}")
+    
+    try:
+        # 캐시 디렉토리 생성
+        Path(cache_dir).mkdir(parents=True, exist_ok=True)
+        
+        # 토크나이저 다운로드
+        logger.info("🔤 토크나이저 다운로드 중...")
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            trust_remote_code=True,
+            cache_dir=cache_dir
+        )
+        logger.info("✅ 토크나이저 다운로드 완료")
+        
+        # 모델 다운로드 (가중치만)
+        logger.info("🧠 모델 다운로드 중...")
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            trust_remote_code=True,
+            cache_dir=cache_dir,
+            torch_dtype="auto",  # 메모리 절약
+            low_cpu_mem_usage=True
+        )
+        logger.info("✅ 모델 다운로드 완료")
+        
+        # 메모리 정리
+        del model
+        del tokenizer
+        
+        logger.info("🎉 모델 다운로드 및 캐시 완료")
+        
+    except Exception as e:
+        logger.error(f"❌ 모델 다운로드 실패: {e}")
+        raise
+
+if __name__ == "__main__":
+    download_model()

fix_huggingface_hub.bat

@@ -0,0 +1,31 @@
+@chcp 65001 >nul
+@echo off
+echo HuggingFace Hub 버전 문제 해결 시작...
+
+cd /d C:\Project\lily_generate_project\lily_generate_package
+
+echo.
+echo 1. latex_ocr_env 활성화...
+call latex_ocr_env\Scripts\activate
+
+echo.
+echo 2. 현재 huggingface_hub 버전 확인...
+python -c "import huggingface_hub; print('현재 버전:', huggingface_hub.__version__)"
+
+echo.
+echo 3. huggingface_hub 다운그레이드 (호환 버전으로)...
+python -m pip install huggingface_hub==0.16.4
+
+echo.
+echo 4. sentence-transformers 재설치...
+python -m pip uninstall sentence-transformers -y
+python -m pip install sentence-transformers==2.2.2
+
+echo.
+echo 5. 설치 확인...
+python -c "import huggingface_hub; print('HuggingFace Hub:', huggingface_hub.__version__)"
+python -c "import sentence_transformers; print('SentenceTransformers')"
+
+echo.
+echo HuggingFace Hub 버전 문제 해결 완료!
+pause 

huggingface_cloud_setup.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""
+Hugging Face 클라우드 GPU 환경 설정
+"""
+
+import os
+import requests
+import json
+import logging
+from huggingface_hub import login, HfApi
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class HuggingFaceCloudSetup:
+    """Hugging Face 클라우드 GPU 설정 클래스"""
+    
+    def __init__(self):
+        """초기화"""
+        self.api = None
+        self.model_name = "heegyu/polyglot-ko-5.8b-chat"
+        self.space_name = "lily-math-rag"
+        
+    def setup_huggingface_login(self):
+        """Hugging Face 로그인 설정"""
+        logger.info("🔐 Hugging Face 로그인 설정")
+        
+        try:
+            # 토큰 입력 요청
+            token = input("Hugging Face 토큰을 입력하세요: ").strip()
+            
+            if token:
+                login(token)
+                self.api = HfApi(token=token)
+                logger.info("✅ Hugging Face 로그인 성공")
+                return True
+            else:
+                logger.error("❌ 토큰이 필요합니다")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ Hugging Face 로그인 실패: {e}")
+            return False
+    
+    def create_inference_endpoint(self):
+        """추론 엔드포인트 생성"""
+        logger.info("🚀 추론 엔드포인트 생성 중...")
+        
+        try:
+            # 엔드포인트 설정
+            endpoint_config = {
+                "account": "your-username",  # Hugging Face 사용자명
+                "name": "lily-math-rag-endpoint",
+                "repository": self.model_name,
+                "framework": "pytorch",
+                "accelerator": "gpu",
+                "instance_type": "gpu.t4.medium",  # GPU 인스턴스 타입
+                "region": "us-east-1",
+                "vendor": "aws"
+            }
+            
+            logger.info("✅ 엔드포인트 설정 완료")
+            logger.info(f"   모델: {self.model_name}")
+            logger.info(f"   GPU: {endpoint_config['instance_type']}")
+            logger.info(f"   지역: {endpoint_config['region']}")
+            
+            return endpoint_config
+            
+        except Exception as e:
+            logger.error(f"❌ 엔드포인트 생성 실패: {e}")
+            return None
+    
+    def create_huggingface_space(self):
+        """Hugging Face Space 생성"""
+        logger.info("🌐 Hugging Face Space 생성 중...")
+        
+        try:
+            # Space 설정
+            space_config = {
+                "name": self.space_name,
+                "type": "gradio",
+                "sdk": "gradio",
+                "title": "Lily Math RAG System",
+                "description": "수학 문제 해결을 위한 RAG 시스템",
+                "license": "mit",
+                "python_version": "3.9"
+            }
+            
+            logger.info("✅ Space 설정 완료")
+            logger.info(f"   Space 이름: {space_config['name']}")
+            logger.info(f"   타입: {space_config['type']}")
+            
+            return space_config
+            
+        except Exception as e:
+            logger.error(f"❌ Space 생성 실패: {e}")
+            return None
+    
+    def upload_model_to_hub(self):
+        """모델을 Hugging Face Hub에 업로드"""
+        logger.info("📤 모델 업로드 중...")
+        
+        try:
+            # 로컬 모델 경로
+            local_model_path = "hearth_llm_model"
+            
+            if os.path.exists(local_model_path):
+                logger.info(f"✅ 로컬 모델 발견: {local_model_path}")
+                
+                # 모델 업로드 (실제로는 Hugging Face CLI 사용)
+                logger.info("💡 다음 명령어로 모델을 업로드하세요:")
+                logger.info(f"   huggingface-cli upload your-username/lily-math-model {local_model_path}")
+                
+                return True
+            else:
+                logger.warning(f"⚠️ 로컬 모델을 찾을 수 없습니다: {local_model_path}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ 모델 업로드 실패: {e}")
+            return False
+    
+    def test_cloud_inference(self, endpoint_url):
+        """클라우드 추론 테스트"""
+        logger.info("🧪 클라우드 추론 테스트")
+        
+        try:
+            # 테스트 요청
+            test_data = {
+                "inputs": "안녕하세요! 수학 문제를 도와주세요.",
+                "parameters": {
+                    "max_length": 100,
+                    "temperature": 0.7
+                }
+            }
+            
+            response = requests.post(
+                f"{endpoint_url}/predict",
+                json=test_data,
+                headers={"Authorization": f"Bearer {os.getenv('HF_TOKEN')}"}
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                logger.info(f"✅ 추론 테스트 성공: {result}")
+                return True
+            else:
+                logger.error(f"❌ 추론 테스트 실패: {response.status_code}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ 추론 테스트 실패: {e}")
+            return False
+
+def main():
+    """메인 설정 함수"""
+    print("🚀 Hugging Face 클라우드 GPU 환경 설정")
+    print("=" * 50)
+    
+    # 1. Hugging Face 설정 클래스 초기화
+    setup = HuggingFaceCloudSetup()
+    
+    # 2. Hugging Face 로그인
+    if not setup.setup_huggingface_login():
+        print("❌ 로그인 실패")
+        return
+    
+    # 3. 추론 엔드포인트 생성
+    endpoint_config = setup.create_inference_endpoint()
+    
+    # 4. Hugging Face Space 생성
+    space_config = setup.create_huggingface_space()
+    
+    # 5. 모델 업로드
+    setup.upload_model_to_hub()
+    
+    print("\n🎉 Hugging Face 클라우드 설정 완료!")
+    print("✅ 다음 단계:")
+    print("1. Hugging Face Inference Endpoints에서 엔드포인트 생성")
+    print("2. 모델을 Hugging Face Hub에 업로드")
+    print("3. Railway Hearth Chat과 연동 설정")
+
+if __name__ == "__main__":
+    main() 

huggingface_gpu_setup.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+Hugging Face GPU 환경 설정
+"""
+
+import os
+import torch
+import logging
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from huggingface_hub import login
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class HuggingFaceGPUSetup:
+    """Hugging Face GPU 설정 클래스"""
+    
+    def __init__(self):
+        """초기화"""
+        self.model_name = "heegyu/polyglot-ko-5.8b-chat"
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+    def setup_environment(self):
+        """환경 설정"""
+        logger.info("🚀 Hugging Face GPU 환경 설정 시작")
+        
+        # CUDA 설정
+        if torch.cuda.is_available():
+            logger.info(f"✅ GPU 사용 가능: {torch.cuda.get_device_name(0)}")
+            logger.info(f"   CUDA 버전: {torch.version.cuda}")
+            logger.info(f"   GPU 메모리: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f}GB")
+        else:
+            logger.warning("⚠️ GPU를 사용할 수 없습니다. CPU 모드로 실행됩니다.")
+        
+        # 환경 변수 설정
+        os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+        os.environ["TOKENIZERS_PARALLELISM"] = "false"
+        
+        return True
+    
+    def setup_quantization(self):
+        """양자화 설정 (메모리 절약)"""
+        logger.info("🔧 양자화 설정")
+        
+        try:
+            # 4-bit 양자화 설정
+            quantization_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=torch.float16,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_use_double_quant=True,
+            )
+            
+            logger.info("✅ 4-bit 양자화 설정 완료")
+            return quantization_config
+            
+        except Exception as e:
+            logger.warning(f"⚠️ 양자화 설정 실패: {e}")
+            return None
+    
+    def load_model_optimized(self, model_name=None):
+        """최적화된 모델 로드"""
+        if model_name:
+            self.model_name = model_name
+            
+        logger.info(f"📥 모델 로드 중: {self.model_name}")
+        
+        try:
+            # 토크나이저 로드
+            tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name,
+                trust_remote_code=True,
+                use_fast=False
+            )
+            
+            # 양자화 설정 적용
+            quantization_config = self.setup_quantization()
+            
+            # 모델 로드
+            if quantization_config:
+                model = AutoModelForCausalLM.from_pretrained(
+                    self.model_name,
+                    quantization_config=quantization_config,
+                    device_map="auto",
+                    trust_remote_code=True,
+                    torch_dtype=torch.float16
+                )
+            else:
+                model = AutoModelForCausalLM.from_pretrained(
+                    self.model_name,
+                    device_map="auto",
+                    trust_remote_code=True,
+                    torch_dtype=torch.float16
+                )
+            
+            logger.info("✅ 모델 로드 완료")
+            return model, tokenizer
+            
+        except Exception as e:
+            logger.error(f"❌ 모델 로드 실패: {e}")
+            return None, None
+    
+    def optimize_memory(self):
+        """메모리 최적화"""
+        logger.info("💾 메모리 최적화")
+        
+        if torch.cuda.is_available():
+            # GPU 메모리 캐시 정리
+            torch.cuda.empty_cache()
+            
+            # 메모리 할당 최적화
+            torch.backends.cudnn.benchmark = True
+            torch.backends.cudnn.deterministic = False
+            
+            # 메모리 사용량 확인
+            memory_allocated = torch.cuda.memory_allocated(0) / 1024**3
+            memory_reserved = torch.cuda.memory_reserved(0) / 1024**3
+            
+            logger.info(f"   할당된 메모리: {memory_allocated:.2f}GB")
+            logger.info(f"   예약된 메모리: {memory_reserved:.2f}GB")
+        
+        return True
+    
+    def test_model_inference(self, model, tokenizer):
+        """모델 추론 테스트"""
+        logger.info("🧪 모델 추론 테스트")
+        
+        try:
+            # 테스트 입력
+            test_input = "안녕하세요! 수학 문제를 도와주세요."
+            
+            # 토크나이징
+            inputs = tokenizer(test_input, return_tensors="pt")
+            if torch.cuda.is_available():
+                inputs = {k: v.cuda() for k, v in inputs.items()}
+            
+            # 추론
+            with torch.no_grad():
+                outputs = model.generate(
+                    **inputs,
+                    max_length=100,
+                    num_return_sequences=1,
+                    temperature=0.7,
+                    do_sample=True,
+                    pad_token_id=tokenizer.eos_token_id
+                )
+            
+            # 결과 디코딩
+            response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+            logger.info(f"✅ 추론 테스트 성공: {response[:50]}...")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 추론 테스트 실패: {e}")
+            return False
+
+def setup_huggingface_login():
+    """Hugging Face 로그인 설정"""
+    logger.info("🔐 Hugging Face 로그인 설정")
+    
+    try:
+        # 토큰 입력 요청
+        token = input("Hugging Face 토큰을 입력하세요 (Enter로 건너뛰기): ").strip()
+        
+        if token:
+            login(token)
+            logger.info("✅ Hugging Face 로그인 성공")
+            return True
+        else:
+            logger.info("⚠️ 토큰을 입력하지 않았습니다. 공개 모델만 사용 가능합니다.")
+            return False
+            
+    except Exception as e:
+        logger.error(f"❌ Hugging Face 로그인 실패: {e}")
+        return False
+
+def main():
+    """메인 설정 함수"""
+    print("🚀 Hugging Face GPU 환경 설정")
+    print("=" * 50)
+    
+    # 1. Hugging Face 로그인
+    setup_huggingface_login()
+    
+    # 2. GPU 설정 클래스 초기화
+    setup = HuggingFaceGPUSetup()
+    
+    # 3. 환경 설정
+    setup.setup_environment()
+    
+    # 4. 메모리 최적화
+    setup.optimize_memory()
+    
+    # 5. 모델 로드 (선택사항)
+    load_model = input("모델을 로드하시겠습니까? (y/N): ").strip().lower()
+    
+    if load_model == 'y':
+        model, tokenizer = setup.load_model_optimized()
+        
+        if model and tokenizer:
+            # 6. 추론 테스트
+            setup.test_model_inference(model, tokenizer)
+    
+    print("\n🎉 Hugging Face GPU 환경 설정 완료!")
+    print("✅ 이제 GPU 환경에서 모델을 사용할 수 있습니다.")
+
+if __name__ == "__main__":
+    main() 

lily-math-rag

@@ -0,0 +1 @@
+Subproject commit e3f9de3c36d6444de4d64dbc3752d3082e7a4b0f

lily_llm_api/app.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""
+Lily LLM API 서버
+파인튜닝된 Mistral-7B 모델을 RESTful API로 서빙
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+import logging
+import time
+import torch
+from typing import Optional, List
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# FastAPI 앱 생성
+app = FastAPI(
+    title="Lily LLM API",
+    description="Hearth Chat용 파인튜닝된 Mistral-7B 모델 API",
+    version="1.0.0"
+)
+
+# CORS 설정
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # 개발용, 프로덕션에서는 특정 도메인만 허용
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Pydantic 모델들
+class GenerateRequest(BaseModel):
+    prompt: str
+    max_length: Optional[int] = 100
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 0.9
+    do_sample: Optional[bool] = True
+
+class GenerateResponse(BaseModel):
+    generated_text: str
+    processing_time: float
+    model_name: str = "Lily LLM (Mistral-7B)"
+
+class HealthResponse(BaseModel):
+    status: str
+    model_loaded: bool
+    model_name: str
+
+# 전역 변수
+model = None
+tokenizer = None
+model_loaded = False
+
+@app.on_event("startup")
+async def startup_event():
+    """서버 시작 시 모델 로드"""
+    global model, tokenizer, model_loaded
+    
+    logger.info("🚀 Lily LLM API 서버 시작 중...")
+    logger.info("📝 API 문서: http://localhost:8001/docs")
+    logger.info("🔍 헬스 체크: http://localhost:8001/health")
+    
+    try:
+        # 모델 로딩 (비동기로 처리하여 서버 시작 속도 향상)
+        await load_model_async()
+        model_loaded = True
+        logger.info("✅ 모델 로딩 완료!")
+    except Exception as e:
+        logger.error(f"❌ 모델 로딩 실패: {e}")
+        model_loaded = False
+
+async def load_model_async():
+    """비동기 모델 로딩"""
+    global model, tokenizer
+    
+    # 모델 로딩은 별도 스레드에서 실행
+    import asyncio
+    import concurrent.futures
+    
+    def load_model_sync():
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        from peft import PeftModel
+        import torch
+        
+        logger.info("모델 로딩 중...")
+        
+        # 로컬 모델 경로 사용
+        local_model_path = "./lily_llm_core/models/polyglot-ko-1.3b"
+        
+        try:
+            # 로컬 모델과 토크나이저 로드
+            tokenizer = AutoTokenizer.from_pretrained(local_model_path, use_fast=True)
+            
+            if tokenizer.pad_token is None:
+                tokenizer.pad_token = tokenizer.eos_token
+            
+            # 모델 로드 (CPU에서)
+            model = AutoModelForCausalLM.from_pretrained(
+                local_model_path,
+                torch_dtype=torch.float32,
+                device_map="cpu",
+                low_cpu_mem_usage=True
+            )
+            
+            logger.info("✅ polyglot-ko-1.3b 모델 로드 성공!")
+            return model, tokenizer
+            
+        except Exception as e:
+            logger.error(f"로컬 모델 로드 실패: {e}")
+            logger.info("테스트용 간단한 모델 로드 중...")
+            
+            # DialoGPT-medium으로 대체 (더 작은 모델)
+            test_model_name = "microsoft/DialoGPT-medium"
+            tokenizer = AutoTokenizer.from_pretrained(test_model_name)
+            model = AutoModelForCausalLM.from_pretrained(test_model_name)
+            
+            return model, tokenizer
+    
+    # 별도 스레드에서 모델 로딩
+    loop = asyncio.get_event_loop()
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        model, tokenizer = await loop.run_in_executor(executor, load_model_sync)
+
+@app.get("/", response_model=dict)
+async def root():
+    """루트 엔드포인트"""
+    return {
+        "message": "Lily LLM API 서버",
+        "version": "1.0.0",
+        "model": "Mistral-7B-Instruct-v0.2 (Fine-tuned)",
+        "docs": "/docs"
+    }
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """헬스 체크 엔드포인트"""
+    return HealthResponse(
+        status="healthy",
+        model_loaded=model_loaded,
+        model_name="Lily LLM (Mistral-7B)"
+    )
+
+@app.post("/generate", response_model=GenerateResponse)
+async def generate_text(request: GenerateRequest):
+    """텍스트 생성 엔드포인트"""
+    global model, tokenizer
+    
+    if not model_loaded or model is None or tokenizer is None:
+        raise HTTPException(status_code=503, detail="모델이 로드되지 않았습니다")
+    
+    start_time = time.time()
+    
+    try:
+        logger.info(f"텍스트 생성 시작: '{request.prompt}'")
+        
+        # polyglot 모델에 맞는 프롬프트 형식으로 수정
+        formatted_prompt = f"질문: {request.prompt}\n답변:"
+        logger.info(f"포맷된 프롬프트: '{formatted_prompt}'")
+        
+        # 입력 토크나이징 - padding 제거하고 패딩 토큰 설정
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+            
+        inputs = tokenizer(formatted_prompt, return_tensors="pt", truncation=True)
+        logger.info(f"입력 토큰 수: {inputs['input_ids'].shape[1]}")
+        
+        # 텍스트 생성 - 더 강력한 설정으로 수정
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs["input_ids"],
+                attention_mask=inputs["attention_mask"],
+                max_new_tokens=request.max_length,
+                do_sample=True,
+                temperature=0.9,  # 더 높은 temperature
+                top_k=50,         # top_k 추가
+                top_p=0.95,       # top_p 추가
+                repetition_penalty=1.2,  # 반복 방지
+                no_repeat_ngram_size=2,  # n-gram 반복 방지
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+        
+        logger.info(f"생성된 토큰 수: {outputs.shape[1]}")
+        
+        # 결과 디코딩
+        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        logger.info(f"디코딩된 전체 텍스트: '{generated_text}'")
+        
+        # polyglot 응답 부분만 추출
+        if "답변:" in generated_text:
+            response = generated_text.split("답변:")[-1].strip()
+            logger.info(f"답변 추출: '{response}'")
+        else:
+            # 기존 방식으로 프롬프트 제거
+            if formatted_prompt in generated_text:
+                response = generated_text.replace(formatted_prompt, "").strip()
+            else:
+                response = generated_text.strip()
+            logger.info(f"프롬프트 제거 후: '{response}'")
+        
+        # 빈 응답 처리
+        if not response.strip():
+            logger.warning("생성된 텍스트가 비어있음, 기본 응답 사용")
+            response = "안녕하세요! 무엇을 도와드릴까요?"
+        
+        processing_time = time.time() - start_time
+        
+        logger.info(f"생성 완료: {processing_time:.2f}초, 텍스트 길이: {len(response)}")
+        
+        return GenerateResponse(
+            generated_text=response,
+            processing_time=processing_time
+        )
+        
+    except Exception as e:
+        logger.error(f"텍스트 생성 오류: {e}")
+        raise HTTPException(status_code=500, detail=f"텍스트 생성 실패: {str(e)}")
+
+@app.get("/models")
+async def list_models():
+    """사용 가능한 모델 목록"""
+    return {
+        "models": [
+            {
+                "id": "lily-llm",
+                "name": "Lily LLM",
+                "description": "Hearth Chat용 파인튜닝된 Mistral-7B 모델",
+                "base_model": "mistralai/Mistral-7B-Instruct-v0.2",
+                "fine_tuned": True
+            }
+        ]
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=8001,
+        reload=False,
+        log_level="info"
+    ) 

lily_llm_api/app_v2.py

@@ -0,0 +1,2049 @@
+#!/usr/bin/env python3
+"""
+Lily LLM API 서버 v2 (인터랙티브 선택 복원 및 성능 최적화 최종본)
+"""
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form, Depends, WebSocket, WebSocketDisconnect
+from fastapi.security import HTTPAuthorizationCredentials
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+import logging
+import time
+import torch
+from datetime import datetime
+from typing import Optional, List, Union
+import asyncio
+import concurrent.futures
+import sys
+from PIL import Image
+import io
+import os
+import json
+from pathlib import Path
+
+from .models import get_model_profile, list_available_models
+from lily_llm_core.rag_processor import rag_processor
+from lily_llm_core.document_processor import document_processor
+from lily_llm_core.hybrid_prompt_generator import hybrid_prompt_generator
+from lily_llm_core.database import db_manager
+from lily_llm_core.auth_manager import auth_manager
+from lily_llm_core.websocket_manager import connection_manager
+from lily_llm_core.celery_app import (
+    process_document_async, generate_ai_response_async, 
+    rag_query_async, batch_process_documents_async,
+    get_task_status, cancel_task
+)
+from lily_llm_core.performance_monitor import performance_monitor
+
+# 이미지 OCR 전용 모듈 추가
+from lily_llm_core.image_rag_processor import image_rag_processor
+from lily_llm_core.latex_rag_processor import latex_rag_processor
+from lily_llm_core.vector_store_manager import vector_store_manager
+
+# LaTeX-OCR + FAISS 통합 시스템 추가
+from latex_ocr_faiss_integrated import LatexOCRFAISSIntegrated
+from latex_ocr_faiss_simple import LatexOCRFAISSSimple
+
+# 멀티모달 RAG 프로세서 추가
+from lily_llm_core.hybrid_rag_processor import hybrid_rag_processor
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# FastAPI 앱 생성
+app = FastAPI(
+    title="Lily LLM API v2",
+    description="다중 모델 지원 LLM API 서버",
+    version="2.0.0"
+)
+
+# 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=["*"],
+)
+
+# Pydantic 모델들
+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
+
+# 전역 변수
+model = None
+tokenizer = None
+current_profile = None
+model_loaded = False
+image_processor = None
+executor = concurrent.futures.ThreadPoolExecutor()
+
+def select_model_interactive():
+    """인터랙티브 모델 선택"""
+    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: sys.exit("\n\n👋 프로그램을 종료합니다.")
+
+@app.on_event("startup")
+async def startup_event():
+    """[복원] 서버 시작 시 인터랙티브 모델 선택 및 로드"""
+    global model_loaded
+    selected_model_id = select_model_interactive()
+    try:
+        await load_model_async(selected_model_id)
+        model_loaded = True
+        logger.info(f"✅ 서버가 '{current_profile.display_name}' 모델로 준비되었습니다.")
+    except Exception as e:
+        logger.error(f"❌ 모델 로드에 실패했습니다: {e}", exc_info=True)
+        model_loaded = False
+
+@app.on_event("shutdown")
+def shutdown_event():
+    executor.shutdown(wait=True)
+
+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, image_processor, current_profile
+    
+    try:
+        # 기존 모델 언로드 (메모리 정리)
+        if model is not None:
+            logger.info("🗑️ 기존 모델 언로드 중...")
+            del model
+            del tokenizer
+            model = None
+            tokenizer = None
+            import gc
+            gc.collect()
+            logger.info("✅ 기존 모델 언로드 완료")
+        
+        logger.info(f"📥 '{model_id}' 모델 로딩 시작...")
+        current_profile = get_model_profile(model_id)
+        model, tokenizer = current_profile.load_model()
+        
+        # 모델 정보 디버그
+        if hasattr(model, 'num_parameters'):
+            logger.info(f"📊 모델 파라미터 수: {model.num_parameters():,}")        
+                        
+        # 멀티모달 토크나이저 설정
+        if getattr(current_profile, 'multimodal', False):
+            logger.info("🔧 토크나이저 멀티모달 기능 활성화...")
+            tokenizer.mllm_setup(num_visual_tokens=1)
+            from transformers import AutoImageProcessor
+            image_processor = AutoImageProcessor.from_pretrained(current_profile.local_path, trust_remote_code=True, local_files_only=True)
+            logger.info("✅ 이미지 프로세서 로드 성공!")
+        else:
+            image_processor = None
+            
+        logger.info(f"✅ '{current_profile.display_name}' 모델 로딩 완료!")                
+        
+    except Exception as e:
+        logger.error(f"❌ load_model_sync 실패: {e}")
+        import traceback
+        logger.error(f"🔍 전체 에러: {traceback.format_exc()}")
+        raise    
+
+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) -> dict:
+    """[최적화] 모델 생성을 처리하는 통합 동기 함수"""
+    image_processed = False
+    all_pixel_values = []
+    combined_image_metas = None
+
+    # --- 1. 이미지 처리 (이미지가 있는 경우에만 실행) ---
+    if image_data_list and getattr(current_profile, 'multimodal', False):
+        logger.info(f"🖼️  멀티모달 요청 처리 시작... (이미지 {len(image_data_list)}개)")
+        image_processed = True
+        all_image_metas = []
+        
+        for i, image_data in enumerate(image_data_list):
+            pil_image = Image.open(io.BytesIO(image_data)).convert("RGB")
+            processed_data = image_processor(pil_image)
+            all_pixel_values.append(processed_data["pixel_values"])
+            all_image_metas.append(processed_data["image_meta"])
+        
+        # 모든 이미지 메타데이터를 하나로 합치기
+        if all_image_metas:
+            combined_image_metas = {}
+            for key in all_image_metas[0].keys():
+                combined_image_metas[key] = [meta[key] for meta in all_image_metas]
+
+    # --- 2. 프롬프트 구성 (이미지 유무에 관계없이 공통 실행) ---
+    image_tokens = "<image>" * len(all_pixel_values)
+    # 텍스트와 멀티모달 모두 동일한 프롬프트 ��플릿 사용
+    formatted_prompt = f"<|im_start|>user\n{image_tokens}{prompt}<|im_end|>\n<|im_start|>assistant\n"
+    
+    # --- 3. 토크나이징 (공통 실행) ---
+    # 텍스트와 멀티모달 모두 동일한 커스텀 토크나이저 함수 사용
+    inputs = tokenizer.encode_prompt(prompt=formatted_prompt, image_meta=combined_image_metas)
+    
+    input_ids = inputs['input_ids'].unsqueeze(0).to(model.device)
+    attention_mask = inputs['attention_mask'].unsqueeze(0).to(model.device)
+    
+    # --- 4. 모델 생성 (공통 실행) ---
+    gen_config = current_profile.get_generation_config()
+    
+    # max_length 등 사용자 지정 파라미터가 있으면 gen_config에 반영
+    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
+
+    with torch.no_grad():
+        if image_processed:
+            # 멀티모달 생성
+            outputs = model.generate(
+                pixel_values=all_pixel_values, 
+                image_metas=combined_image_metas,
+                input_ids=input_ids, 
+                attention_mask=attention_mask,
+                **gen_config
+            )
+        else:
+            # 텍스트 전용 생성 (최적화된 경로 사용)
+            outputs = model.generate(
+                input_ids=input_ids, 
+                attention_mask=attention_mask,
+                **gen_config
+            )
+
+    # --- 5. 응답 추출 (공통 로직) ---
+    try:
+        full_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        response = current_profile.extract_response(full_text, formatted_prompt)
+        return {"text": response, "image_processed": image_processed}
+    except Exception as e:
+        logger.error(f"❌ 응답 추출 중 오류: {e}")
+        raise HTTPException(status_code=500, detail=f"응답 추출 중 오류가 발생했습니다: {str(e)}")
+
+@app.post("/generate", response_model=GenerateResponse)
+async def generate(prompt: str = Form(...), 
+                  image1: UploadFile = File(None),
+                  image2: UploadFile = File(None),
+                  image3: UploadFile = File(None),
+                  image4: UploadFile = File(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 model_loaded:
+        raise HTTPException(status_code=503, detail="모델이 로드되지 않았습니다.")
+
+    start_time = time.time()
+    loop = asyncio.get_event_loop()
+    
+    # 다중 이미지 처리
+    image_data_list = []
+    for img in [image1, image2, image3, image4]:
+        if img:
+            image_data = await img.read()
+            image_data_list.append(image_data)
+
+    result = await loop.run_in_executor(executor, generate_sync, prompt, image_data_list, 
+                                      max_length, temperature, top_p, do_sample)
+    
+    processing_time = time.time() - start_time
+    logger.info(f"✅ 생성 완료 ({processing_time:.2f}초), 이미지 처리: {result['image_processed']}")
+
+    return GenerateResponse(
+        generated_text=result["text"],
+        processing_time=processing_time,
+        model_name=current_profile.display_name,
+        image_processed=result["image_processed"]
+    )
+
+@app.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)
+):
+    """멀티모달 텍스트 생성 (이미지 + 텍스트)"""
+    start_time = time.time()
+    
+    try:
+        # 모델 로드 확인
+        if not model_loaded or not model or not tokenizer or not current_profile:
+            raise HTTPException(status_code=500, detail="모델이 로드되지 않았습니다")
+        
+        # Kanana 모델이 아니면 일반 텍스트 생성으로 리다이렉트
+        if "kanana" not in current_profile.model_name.lower():
+            logger.warning("멀티모달 요청이지만 Kanana 모델이 아님 - 일반 텍스트 생성으로 처리")
+            # 일반 generate 엔드포인트로 리다이렉트
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(executor, generate_sync, prompt, None, 
+                                              max_length, temperature, top_p, do_sample)
+            return MultimodalGenerateResponse(
+                generated_text=result["text"],
+                processing_time=time.time() - start_time,
+                model_name=current_profile.display_name,
+                model_id=model_id or current_profile.get_model_info()["model_name"],
+                image_processed=False
+            )
+        
+        logger.info(f"🖼️ 멀티모달 생성 시작: '{prompt}'")
+        
+        # 이미지 처리
+        pixel_values = None
+        image_metas = None
+        image_processed = False
+        if image:
+            logger.info(f"📸 이미지 처리 중: {image.filename}")
+            try:
+                # 이미지 파일 읽기
+                image_data = await image.read()
+                pil_image = Image.open(io.BytesIO(image_data))
+                
+                # 이미지 전처리 (Kanana 모델에 맞게)
+                logger.info(f"✅ 이미지 로드 완료: {pil_image.size}")
+                
+                # Kanana 모델의 이미지 전처리
+                from transformers import AutoImageProcessor
+                
+                # 이미지 프로세서 로드
+                image_processor = AutoImageProcessor.from_pretrained(
+                    current_profile.get_model_info()["local_path"],
+                    trust_remote_code=True
+                )
+                
+                # 이미지 전처리 (Kanana 방식)
+                processed_images = image_processor(pil_image)
+                pixel_values = processed_images["pixel_values"]
+                image_metas = processed_images["image_meta"]
+                
+                # 디바이스로 이동
+                pixel_values = pixel_values.to(model.device)
+                if image_metas and "vision_grid_thw" in image_metas:
+                    # vision_grid_thw가 스칼라가 아닌 텐서인지 확인
+                    grid_thw = image_metas["vision_grid_thw"]
+                    if isinstance(grid_thw, (list, tuple)):
+                        grid_thw = torch.tensor(grid_thw)
+                    elif not isinstance(grid_thw, torch.Tensor):
+                        grid_thw = torch.tensor([grid_thw])
+                    image_metas["vision_grid_thw"] = grid_thw.to(model.device)
+                
+                # 디버깅을 위한 로그 추가
+                logger.info(f"🔍 pixel_values 형태: {pixel_values.shape}")
+                logger.info(f"🔍 image_metas keys: {list(image_metas.keys()) if image_metas else 'None'}")
+                if image_metas and "vision_grid_thw" in image_metas:
+                    logger.info(f"🔍 vision_grid_thw 형태: {image_metas['vision_grid_thw'].shape}")
+                
+                image_processed = True
+                logger.info(f"✅ 이미지 텐서 변환 완료: {pixel_values.shape}")
+                
+            except Exception as e:
+                logger.error(f"❌ 이미지 처리 실패: {e}")
+                pixel_values = None
+                image_metas = None
+                image_processed = False
+                logger.info("📝 이미지 없이 텍스트만 처리합니다.")
+        else:
+            logger.info("📸 이미지 없음 - 텍스트만 처리")
+            image_processed = False
+        
+        # Kanana 멀티모달 프롬프트 형식
+        system_prompt = "당신은 한국어로 대화하는 AI 어시스턴트입니다. 모든 응답은 한국어로 해주세요."
+        if image_processed:
+            formatted_prompt = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+            logger.info(f"🖼️ Kanana 멀티모달 프롬프트: '{formatted_prompt}'")
+        else:
+            formatted_prompt = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+            logger.info(f"🔍 Kanana 텍스트 전용 프롬프트: '{formatted_prompt}'")
+        
+        # 토크나이징
+        inputs = tokenizer(
+            formatted_prompt, 
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=100,
+        )
+        
+        if 'token_type_ids' in inputs:
+            del inputs['token_type_ids']
+        
+        inputs = {k: v.to(model.device) for k, v in inputs.items()}
+        logger.info(f"입력 토큰 수: {inputs['input_ids'].shape[1]}")
+        
+        # Kanana용 생성 설정
+        max_new_tokens = max_length or 100
+        temperature = temperature or 0.7
+        top_p = top_p or 0.9
+        do_sample = do_sample if do_sample is not None else True
+        
+        with torch.no_grad():
+            if image_processed and pixel_values is not None:
+                # Kanana 모델의 실제 멀티모달 처리 시도
+                logger.info("🔍 Kanana 모델의 실제 멀티모달 처리 시도...")
+                
+                try:
+                    # vision_grid_thw를 올바른 형태로 변환 시도
+                    if 'vision_grid_thw' in image_metas:
+                        grid_thw = image_metas['vision_grid_thw']
+                        if isinstance(grid_thw, (list, tuple)):
+                            grid_thw = torch.tensor(grid_thw)
+                        elif not isinstance(grid_thw, torch.Tensor):
+                            grid_thw = torch.tensor([grid_thw])
+                        image_metas['vision_grid_thw'] = grid_thw.to(model.device)
+                    
+                    # forward_vision과 forward_projector를 분리해서 시도
+                    visual_features = model.forward_vision(pixel_values, image_metas)
+                    visual_embeds = model.forward_projector(visual_features, image_metas)
+                    
+                    # 텍스트 임베딩 생성
+                    text_embeds = model.embed_text_tokens(inputs["input_ids"])
+                    
+                    # 시각적 임베딩을 텍스트 임베딩과 같은 dtype으로 변환
+                    target_dtype = text_embeds.dtype
+                    visual_embeds_converted = visual_embeds.to(target_dtype)
+                    
+                    # 텍스트 임베딩을 평면화
+                    from einops import rearrange
+                    flattened_text_embeds = rearrange(text_embeds, "b l d -> (b l) d")
+                    flattened_input_ids = rearrange(inputs["input_ids"], "b l -> (b l)")
+                    
+                    # -1 토큰 위치에 시각적 임베딩 삽입
+                    mask = (flattened_input_ids == -1)
+                    if mask.sum() > 0:
+                        flattened_text_embeds[mask] = visual_embeds_converted[:mask.sum()]
+                    
+                    # 다시 배치 형태로 재구성
+                    input_embeds = rearrange(flattened_text_embeds, "(b l) d -> b l d", b=inputs["input_ids"].shape[0])
+                    attention_mask = inputs["attention_mask"]
+                    
+                    # 언어 모델의 dtype에 맞춰 input_embeds 변환
+                    language_model_dtype = next(model.language_model.parameters()).dtype
+                    if input_embeds.dtype != language_model_dtype:
+                        input_embeds = input_embeds.to(language_model_dtype)
+                    
+                    # Kanana 모델의 원래 generate 메서드 사용
+                    outputs = model.generate(
+                        input_ids=inputs["input_ids"],
+                        pixel_values=pixel_values,
+                        image_metas=image_metas,
+                        attention_mask=inputs["attention_mask"],
+                        max_new_tokens=max_new_tokens,
+                        do_sample=do_sample,
+                        temperature=temperature,
+                        top_k=40,
+                        top_p=top_p,
+                        repetition_penalty=1.1,
+                        no_repeat_ngram_size=2,
+                        pad_token_id=tokenizer.eos_token_id,
+                        eos_token_id=tokenizer.eos_token_id,
+                        use_cache=True
+                    )
+                    logger.info("✅ 실제 멀티모달 생성 성공!")
+                    
+                except Exception as e:
+                    logger.error(f"❌ 실제 멀티모달 처리 실패: {e}")
+                    logger.error(f"🔍 오류 타입: {type(e).__name__}")
+                    import traceback
+                    logger.error(f"🔍 상세 오류: {traceback.format_exc()}")
+                    logger.info("🔄 fallback: 텍스트 전용 처리로 전환")
+                    
+                    # fallback: 텍스트 전용 처리
+                    enhanced_prompt = f"[이미지 첨부됨] {prompt}"
+                    enhanced_formatted_prompt = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{enhanced_prompt}<|im_end|>\n<|im_start|>assistant\n"
+                    
+                    enhanced_inputs = tokenizer(
+                        enhanced_formatted_prompt, 
+                        return_tensors="pt",
+                        padding=True,
+                        truncation=True,
+                        max_length=256
+                    )
+                    
+                    if 'token_type_ids' in enhanced_inputs:
+                        del enhanced_inputs['token_type_ids']
+                    
+                    enhanced_inputs = {k: v.to(model.device) for k, v in enhanced_inputs.items()}
+                    
+                    outputs = model.language_model.generate(
+                        input_ids=enhanced_inputs["input_ids"],
+                        attention_mask=enhanced_inputs["attention_mask"],
+                        max_new_tokens=max_new_tokens,
+                        do_sample=do_sample,
+                        temperature=temperature,
+                        top_k=40,
+                        top_p=top_p,
+                        repetition_penalty=1.1,
+                        no_repeat_ngram_size=2,
+                        pad_token_id=tokenizer.eos_token_id,
+                        eos_token_id=tokenizer.eos_token_id,
+                        use_cache=True
+                    )
+            else:
+                # 텍스트 전용 생성
+                logger.info("📝 텍스트 전용 생성 시작")
+                outputs = model.generate(
+                    input_ids=inputs["input_ids"],
+                    attention_mask=inputs["attention_mask"],
+                    max_new_tokens=max_new_tokens,
+                    do_sample=do_sample,
+                    temperature=temperature,
+                    top_k=40,
+                    top_p=top_p,
+                    repetition_penalty=1.1,
+                    no_repeat_ngram_size=2,
+                    pad_token_id=tokenizer.eos_token_id,
+                    eos_token_id=tokenizer.eos_token_id,
+                    use_cache=True
+                )
+        
+        # 응답 추출
+        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        logger.info(f"생성된 토큰 수: {outputs.shape[1]}")
+        logger.info(f"디코딩된 전체 텍스트: '{generated_text}'")
+        
+        # Kanana 멀티모달 응답 추출
+        if "<|im_start|>assistant" in generated_text:
+            response = generated_text.split("<|im_start|>assistant")[-1].split("<|im_end|>")[0].strip()
+            logger.info(f"🔍 Kanana 멀티모달 응답 추출: '{response}'")
+        else:
+            response = generated_text.strip()
+            logger.info(f"🔍 Kanana 전체 텍스트: '{response}'")
+        
+        processing_time = time.time() - start_time
+        logger.info(f"멀티모달 생성 완료: {processing_time:.2f}초, 텍스트 길이: {len(response)}, 이미지 처리: {image_processed}")
+        
+        return MultimodalGenerateResponse(
+            generated_text=response,
+            processing_time=processing_time,
+            model_name=current_profile.display_name,
+            model_id=model_id or current_profile.get_model_info()["model_name"],
+            image_processed=image_processed
+        )
+        
+    except Exception as e:
+        processing_time = time.time() - start_time
+        logger.error(f"❌ 멀티모달 생성 오류: {e} (소요 시간: {processing_time:.2f}초)")
+        raise HTTPException(status_code=500, detail=f"멀티모달 생성 실패: {str(e)}")
+
+@app.get("/models")
+async def list_models():
+    """사용 가능한 모델 목록"""
+    return {
+        "models": list_available_models(),
+        "current_model": current_profile.get_model_info() if current_profile else None
+    }
+
+@app.post("/switch-model")
+async def switch_model(model_id: str):
+    """모델 변경"""
+    try:
+        await load_model_async(model_id)
+        return {
+            "message": f"모델 변경 성공: {model_id}",
+            "current_model": current_profile.display_name
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"모델 변경 실패: {str(e)}")
+    
+@app.get("/", response_model=dict)
+async def root():
+    """루트 엔드포인트"""
+    return {
+        "message": "Lily LLM API v2 서버",
+        "version": "2.0.0",
+        "current_model": current_profile.display_name if current_profile else "None",
+        "docs": "/docs"
+    }
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """헬스 체크 엔드포인트"""
+    available_models = list_available_models()
+    
+    return HealthResponse(
+        status="healthy",
+        model_loaded=model_loaded,
+        current_model=current_profile.display_name if current_profile else "None",
+        available_models=available_models
+    )
+
+@app.post("/document/upload", response_model=DocumentUploadResponse)
+async def upload_document(
+    file: UploadFile = File(...),
+    user_id: str = Form("default_user"),  # 기본 사용자 ID
+    document_id: Optional[str] = Form(None)  # 문서 ID (자동 생성 가능)
+):
+    """문서 업로드 및 RAG 처리"""
+    start_time = time.time()
+    
+    try:
+        # 문서 ID 생성 (제공되지 않은 경우)
+        if not document_id:
+            import uuid
+            document_id = str(uuid.uuid4())[:8]
+        
+        # 임시 파일 저장
+        temp_file_path = f"./temp_{document_id}_{file.filename}"
+        with open(temp_file_path, "wb") as f:
+            content = await file.read()
+            f.write(content)
+        
+        # 문서 처리 및 벡터 스토어에 저장
+        result = rag_processor.process_and_store_document(
+            user_id, document_id, temp_file_path
+        )
+        
+        # 임시 파일 삭제
+        import os
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+        
+        processing_time = time.time() - start_time
+        logger.info(f"📄 문서 업로드 완료 ({processing_time:.2f}초): {file.filename}")
+        
+        # 문서 업로드 후 자동으로 AI 응답 생성
+        if result["success"]:
+            try:
+                # 간단한 요약 질문으로 AI 응답 생성
+                summary_query = f"업로드된 문서 '{file.filename}'의 주요 내용을 요약해주세요."
+                
+                logger.info(f"🤖 문서 업로드 후 AI 응답 생성 시작...")
+                
+                rag_result = rag_processor.generate_rag_response(
+                    user_id, document_id, summary_query, llm_model=model
+                )
+                
+                if rag_result["success"]:
+                    logger.info(f"✅ 자동 AI 응답 생성 완료: {len(rag_result['response'])} 문자")
+                    result["auto_response"] = rag_result["response"]
+                else:
+                    logger.warning(f"⚠️ 자동 AI 응답 생성 실패: {rag_result.get('error', 'Unknown error')}")
+                    
+            except Exception as e:
+                logger.error(f"❌ 자동 AI 응답 생성 중 오류: {e}")
+        
+        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"❌ 문서 업로드 실패: {e}")
+        return DocumentUploadResponse(
+            success=False,
+            document_id=document_id if 'document_id' in locals() else "unknown",
+            message="문서 업로드 중 오류가 발생했습니다.",
+            error=str(e)
+        )
+
+@app.post("/rag/generate", response_model=RAGResponse)
+async def generate_rag_response(
+    query: str = Form(...),
+    user_id: str = Form("default_user"),
+    document_id: str = Form(...),
+    max_length: Optional[int] = Form(None),
+    temperature: Optional[float] = Form(None),
+    top_p: Optional[float] = Form(None),
+    do_sample: Optional[bool] = Form(None)
+):
+    """RAG 기반 응답 생성"""
+    start_time = time.time()
+    
+    try:
+        # 모델이 로드되었는지 확인
+        llm_model = None
+        if model is not None and hasattr(model, 'generate_text'):
+            llm_model = model
+            logger.info("✅ 로드된 모델을 사용하여 RAG 응답 생성")
+        else:
+            logger.warning("⚠️ 모델이 로드되지 않아 텍스트 기반 응답만 생성")
+        
+        # RAG 응답 생성
+        result = rag_processor.generate_rag_response(
+            user_id, document_id, query, llm_model=llm_model
+        )
+        
+        processing_time = time.time() - start_time
+        logger.info(f"🔍 RAG 응답 생성 완료 ({processing_time:.2f}초)")
+        
+        return RAGResponse(
+            success=result["success"],
+            response=result["response"],
+            context=result["context"],
+            sources=result["sources"],
+            search_results=result["search_results"],
+            processing_time=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
+        )
+
+@app.post("/rag/generate-hybrid", response_model=RAGResponse)
+async def generate_hybrid_rag_response(
+    query: str = Form(...),
+    user_id: str = Form("default_user"),
+    document_id: str = Form(...),
+    image1: UploadFile = File(None),
+    image2: UploadFile = File(None),
+    image3: UploadFile = File(None),
+    image4: UploadFile = File(None),
+    image5: UploadFile = File(None),
+    max_length: Optional[int] = Form(None),
+    temperature: Optional[float] = Form(None),
+    top_p: Optional[float] = Form(None),
+    do_sample: Optional[bool] = Form(None)
+):
+    """하이브리드 RAG 기반 응답 생성 (이미지 + 문서)"""
+    start_time = time.time()
+    
+    try:
+        # 이미지 파일 처리
+        image_files = []
+        uploaded_images = [image1, image2, image3, image4, image5]
+        
+        for i, img in enumerate(uploaded_images):
+            if img:
+                try:
+                    # 임시 파일로 저장
+                    import tempfile
+                    with tempfile.NamedTemporaryFile(
+                        suffix=f"_{i}.png", 
+                        delete=False, 
+                        prefix="hybrid_image_"
+                    ) as temp_file:
+                        image_data = await img.read()
+                        temp_file.write(image_data)
+                        image_files.append(temp_file.name)
+                        logger.info(f"📸 이미지 업로드: {img.filename} -> {temp_file.name}")
+                except Exception as e:
+                    logger.error(f"❌ 이미지 처리 실패: {e}")
+        
+        # RAG 응답 생성 (이미지 포함)
+        result = rag_processor.generate_rag_response(
+            user_id, document_id, query, 
+            llm_model=model,  # 실제 모델 인스턴스 사용
+            image_files=image_files if image_files else None
+        )
+        
+        # 임시 이미지 파일 정리
+        for temp_file in image_files:
+            try:
+                if os.path.exists(temp_file):
+                    os.remove(temp_file)
+                    logger.info(f"🗑️ 임시 이미지 파일 삭제: {temp_file}")
+            except Exception as e:
+                logger.warning(f"⚠️ 임시 파일 삭제 실패: {e}")
+        
+        processing_time = time.time() - start_time
+        logger.info(f"🔍 하이브리드 RAG 응답 생성 완료 ({processing_time:.2f}초)")
+        
+        return RAGResponse(
+            success=result["success"],
+            response=result["response"],
+            context=result["context"],
+            sources=result["sources"],
+            search_results=result["search_results"],
+            processing_time=processing_time
+        )
+        
+    except Exception as e:
+        logger.error(f"❌ 하이브리드 RAG 응답 생성 실패: {e}")
+        return RAGResponse(
+            success=False,
+            response=f"응답 생성 중 오류가 발생했습니다: {str(e)}",
+            context="",
+            sources=[],
+            search_results=0,
+            processing_time=time.time() - start_time
+        )
+
+@app.get("/documents/{user_id}")
+async def list_user_documents(user_id: str):
+    """사용자의 문서 목록 조회"""
+    try:
+        from lily_llm_core.vector_store_manager import vector_store_manager
+        documents = vector_store_manager.get_all_documents(user_id)
+        return documents
+    except Exception as e:
+        logger.error(f"❌ 문서 목록 조회 실패: {e}")
+        return {"documents": [], "total_docs": 0, "error": str(e)}
+
+@app.delete("/document/{user_id}/{document_id}")
+async def delete_document(user_id: str, document_id: str):
+    """문서 삭제"""
+    try:
+        result = rag_processor.delete_document(user_id, document_id)
+        return result
+    except Exception as e:
+        logger.error(f"❌ 문서 삭제 실패: {e}")
+        return {"success": False, "error": str(e)}
+
+# 사용자 관리 엔드포인트
+@app.post("/user/create", response_model=UserResponse)
+async def create_user(
+    user_id: str = Form(...),
+    username: Optional[str] = Form(None),
+    email: Optional[str] = Form(None)
+):
+    """사용자 생성"""
+    try:
+        success = db_manager.add_user(user_id, username, email)
+        if success:
+            user_info = db_manager.get_user(user_id)
+            return UserResponse(
+                success=True,
+                user_id=user_id,
+                username=user_info.get('username') if user_info else None,
+                email=user_info.get('email') if user_info else None,
+                created_at=user_info.get('created_at') if user_info else None
+            )
+        else:
+            return UserResponse(success=False, user_id=user_id, error="사용자 생성 실패")
+    except Exception as e:
+        logger.error(f"❌ 사용자 생성 오류: {e}")
+        return UserResponse(success=False, user_id=user_id, error=str(e))
+
+@app.get("/user/{user_id}", response_model=UserResponse)
+async def get_user_info(user_id: str):
+    """사용자 정보 조회"""
+    try:
+        user_info = db_manager.get_user(user_id)
+        if user_info:
+            return UserResponse(
+                success=True,
+                user_id=user_id,
+                username=user_info.get('username'),
+                email=user_info.get('email'),
+                created_at=user_info.get('created_at')
+            )
+        else:
+            return UserResponse(success=False, user_id=user_id, error="사용자를 찾을 수 없습니다")
+    except Exception as e:
+        logger.error(f"❌ 사용자 조회 오류: {e}")
+        return UserResponse(success=False, user_id=user_id, error=str(e))
+
+# 세션 관리 엔드포인트
+@app.post("/session/create", response_model=SessionResponse)
+async def create_session(
+    user_id: str = Form(...),
+    session_name: Optional[str] = Form(None)
+):
+    """채팅 세션 생성"""
+    try:
+        session_id = db_manager.create_chat_session(user_id, session_name)
+        if session_id:
+            return SessionResponse(
+                success=True,
+                session_id=session_id,
+                session_name=session_name
+            )
+        else:
+            return SessionResponse(success=False, session_id="", error="세션 생성 실패")
+    except Exception as e:
+        logger.error(f"❌ 세션 생성 오류: {e}")
+        return SessionResponse(success=False, session_id="", error=str(e))
+
+@app.get("/sessions/{user_id}")
+async def list_user_sessions(user_id: str):
+    """사용자의 세션 목록 조회"""
+    try:
+        sessions = db_manager.get_user_sessions(user_id)
+        return {
+            "success": True,
+            "user_id": user_id,
+            "sessions": sessions,
+            "total_sessions": len(sessions)
+        }
+    except Exception as e:
+        logger.error(f"❌ 세션 목록 조회 오류: {e}")
+        return {"success": False, "error": str(e)}
+
+# 채팅 메시지 엔드포인트
+@app.post("/chat/message", response_model=ChatMessageResponse)
+async def add_chat_message(
+    session_id: str = Form(...),
+    user_id: str = Form(...),
+    message_type: str = Form(...),
+    content: str = Form(...)
+):
+    """채팅 메시지 추가"""
+    try:
+        success = db_manager.add_chat_message(session_id, user_id, message_type, content)
+        if success:
+            return ChatMessageResponse(
+                success=True,
+                message_id=0,  # 실제 ID는 DB에서 자동 생성
+                content=content,
+                message_type=message_type,
+                timestamp=datetime.now().isoformat()
+            )
+        else:
+            return ChatMessageResponse(
+                success=False,
+                message_id=0,
+                content="",
+                message_type="",
+                timestamp="",
+                error="메시지 추가 실패"
+            )
+    except Exception as e:
+        logger.error(f"❌ 메시지 추가 오류: {e}")
+        return ChatMessageResponse(
+            success=False,
+            message_id=0,
+            content="",
+            message_type="",
+            timestamp="",
+            error=str(e)
+        )
+
+@app.get("/chat/history/{session_id}")
+async def get_chat_history(session_id: str, limit: int = 50):
+    """채팅 히스토리 조회"""
+    try:
+        messages = db_manager.get_chat_history(session_id, limit)
+        return {
+            "success": True,
+            "session_id": session_id,
+            "messages": messages,
+            "total_messages": len(messages)
+        }
+    except Exception as e:
+        logger.error(f"❌ 채팅 히스토리 조회 오류: {e}")
+        return {"success": False, "error": str(e)}
+
+# 문서 관리 엔드포인트 (DB 연동)
+@app.get("/documents/db/{user_id}")
+async def list_user_documents_db(user_id: str):
+    """사용자의 문서 목록 조회 (DB 기반)"""
+    try:
+        documents = db_manager.get_user_documents(user_id)
+        return {
+            "success": True,
+            "user_id": user_id,
+            "documents": documents,
+            "total_documents": len(documents)
+        }
+    except Exception as e:
+        logger.error(f"❌ 문서 목록 조회 오류: {e}")
+        return {"success": False, "error": str(e)}
+
+# 인증 엔드포인트
+@app.post("/auth/login", response_model=LoginResponse)
+async def login(
+    user_id: str = Form(...),
+    password: str = Form(...)
+):
+    """사용자 로그인"""
+    try:
+        # 사용자 정보 조회
+        user_info = db_manager.get_user(user_id)
+        if not user_info:
+            return LoginResponse(success=False, error="사용자를 찾을 수 없습니다")
+        
+        # 비밀번호 검증 (간단한 검증 - 실제로는 DB에 저장된 해시와 비교)
+        if not auth_manager.verify_password(password, "dummy_hash"):  # 실제 구현에서는 DB의 해시와 비교
+            return LoginResponse(success=False, error="비밀번호가 올바르지 않습니다")
+        
+        # 토큰 생성
+        tokens = auth_manager.create_user_tokens(user_id, user_info.get('username'))
+        
+        return LoginResponse(
+            success=True,
+            access_token=tokens['access_token'],
+            refresh_token=tokens['refresh_token'],
+            token_type=tokens['token_type'],
+            user_id=user_id,
+            username=user_info.get('username')
+        )
+    except Exception as e:
+        logger.error(f"❌ 로그인 오류: {e}")
+        return LoginResponse(success=False, error=str(e))
+
+@app.post("/auth/refresh", response_model=TokenResponse)
+async def refresh_token(refresh_token: str = Form(...)):
+    """액세스 토큰 갱신"""
+    try:
+        new_access_token = auth_manager.refresh_access_token(refresh_token)
+        
+        if new_access_token:
+            return TokenResponse(
+                success=True,
+                access_token=new_access_token,
+                token_type="bearer"
+            )
+        else:
+            return TokenResponse(success=False, error="유효하지 않은 리프레시 토큰입니다")
+    except Exception as e:
+        logger.error(f"❌ 토큰 갱신 오류: {e}")
+        return TokenResponse(success=False, error=str(e))
+
+@app.post("/auth/register", response_model=LoginResponse)
+async def register(
+    user_id: str = Form(...),
+    username: str = Form(...),
+    password: str = Form(...),
+    email: Optional[str] = Form(None)
+):
+    """사용자 등록"""
+    try:
+        # 기존 사용자 확인
+        existing_user = db_manager.get_user(user_id)
+        if existing_user:
+            return LoginResponse(success=False, error="이미 존재하는 사용자 ID입니다")
+        
+        # 비밀번호 해싱
+        hashed_password = auth_manager.hash_password(password)
+        
+        # 사용자 생성 (실제 구현에서는 hashed_password를 DB에 저장)
+        success = db_manager.add_user(user_id, username, email)
+        
+        if success:
+            # 토큰 생성
+            tokens = auth_manager.create_user_tokens(user_id, username)
+            
+            return LoginResponse(
+                success=True,
+                access_token=tokens['access_token'],
+                refresh_token=tokens['refresh_token'],
+                token_type=tokens['token_type'],
+                user_id=user_id,
+                username=username
+            )
+        else:
+            return LoginResponse(success=False, error="사용자 등록에 실패했습니다")
+    except Exception as e:
+        logger.error(f"❌ 사용자 등록 오류: {e}")
+        return LoginResponse(success=False, error=str(e))
+
+@app.get("/auth/me")
+async def get_current_user_info(credentials: HTTPAuthorizationCredentials = Depends(auth_manager.security)):
+    """현재 사용자 정보 조회"""
+    try:
+        user_info = auth_manager.get_current_user(credentials)
+        return {
+            "success": True,
+            "user_id": user_info.get("sub"),
+            "username": user_info.get("username"),
+            "token_type": user_info.get("type")
+        }
+    except Exception as e:
+        logger.error(f"❌ 사용자 정보 조회 오류: {e}")
+        return {"success": False, "error": str(e)}
+    
+# WebSocket 실시간 채팅 엔드포인트
+@app.websocket("/ws/{user_id}")
+async def websocket_endpoint(websocket: WebSocket, user_id: str, session_id: str = None):
+    """WebSocket 실시간 채팅 엔드포인트"""
+    try:
+        # 연결 수락
+        await connection_manager.connect(websocket, user_id, session_id)
+        
+        # 연결 상태 브로드캐스트
+        await connection_manager.broadcast_message({
+            "type": "user_connected",
+            "user_id": user_id,
+            "session_id": session_id,
+            "timestamp": datetime.now().isoformat()
+        }, exclude_user=user_id)
+        
+        # 메시지 수신 루프
+        while True:
+            try:
+                # 메시지 수신
+                data = await websocket.receive_text()
+                message_data = json.loads(data)
+                
+                # 메시지 타입에 따른 처리
+                message_type = message_data.get("type", "chat")
+                
+                if message_type == "chat":
+                    # 채팅 메시지 처리
+                    content = message_data.get("content", "")
+                    session_id = message_data.get("session_id")
+                    
+                    # DB에 메시지 저장
+                    if session_id:
+                        db_manager.add_chat_message(
+                            session_id=session_id,
+                            user_id=user_id,
+                            message_type="user",
+                            content=content
+                        )
+                    
+                    # 세션의 다른 사용자들에게 메시지 전송
+                    await connection_manager.send_session_message({
+                        "type": "chat_message",
+                        "user_id": user_id,
+                        "content": content,
+                        "session_id": session_id,
+                        "timestamp": datetime.now().isoformat()
+                    }, session_id, exclude_user=user_id)
+                    
+                    # AI 응답 생성 (선택적)
+                    if message_data.get("generate_ai_response", False):
+                        # AI 응답 생성 로직
+                        ai_response = await generate_ai_response(content, user_id)
+                        
+                        # AI 응답을 DB에 저장
+                        if session_id:
+                            db_manager.add_chat_message(
+                                session_id=session_id,
+                                user_id="ai_assistant",
+                                message_type="assistant",
+                                content=ai_response
+                            )
+                        
+                        # AI 응답을 세션 사용자들에게 전송
+                        await connection_manager.send_session_message({
+                            "type": "ai_response",
+                            "user_id": "ai_assistant",
+                            "content": ai_response,
+                            "session_id": session_id,
+                            "timestamp": datetime.now().isoformat()
+                        }, session_id)
+                
+                elif message_type == "typing":
+                    # 타이핑 상태 전송
+                    await connection_manager.send_session_message({
+                        "type": "user_typing",
+                        "user_id": user_id,
+                        "session_id": message_data.get("session_id"),
+                        "timestamp": datetime.now().isoformat()
+                    }, message_data.get("session_id"), exclude_user=user_id)
+                
+                elif message_type == "join_session":
+                    # 세션 참여
+                    new_session_id = message_data.get("session_id")
+                    if new_session_id:
+                        # 기존 세션에서 제거
+                        if user_id in connection_manager.connection_info:
+                            old_session_id = connection_manager.connection_info[user_id].get("session_id")
+                            if old_session_id and old_session_id in connection_manager.session_connections:
+                                connection_manager.session_connections[old_session_id].discard(user_id)
+                        
+                        # 새 세션에 추가
+                        if new_session_id not in connection_manager.session_connections:
+                            connection_manager.session_connections[new_session_id] = set()
+                        connection_manager.session_connections[new_session_id].add(user_id)
+                        
+                        # 연결 정보 업데이트
+                        if user_id in connection_manager.connection_info:
+                            connection_manager.connection_info[user_id]["session_id"] = new_session_id
+                        
+                        # 세션 참여 알림
+                        await connection_manager.send_session_message({
+                            "type": "user_joined_session",
+                            "user_id": user_id,
+                            "session_id": new_session_id,
+                            "timestamp": datetime.now().isoformat()
+                        }, new_session_id, exclude_user=user_id)
+                
+                logger.info(f"📨 WebSocket 메시지 처리: {user_id} - {message_type}")
+                
+            except WebSocketDisconnect:
+                logger.info(f"🔌 WebSocket 연결 끊김: {user_id}")
+                break
+            except json.JSONDecodeError:
+                logger.warning(f"⚠️ 잘못된 JSON 형식: {user_id}")
+                await websocket.send_text(json.dumps({
+                    "type": "error",
+                    "message": "잘못된 메시지 형식입니다."
+                }))
+            except Exception as e:
+                logger.error(f"❌ WebSocket 메시지 처리 오류: {e}")
+                await websocket.send_text(json.dumps({
+                    "type": "error",
+                    "message": "메시지 처리 중 오류가 발생했습니다."
+                }))
+    
+    except WebSocketDisconnect:
+        logger.info(f"🔌 WebSocket 연결 끊김: {user_id}")
+    except Exception as e:
+        logger.error(f"❌ WebSocket 엔드포인트 오류: {e}")
+    finally:
+        # 연결 해제
+        connection_manager.disconnect(user_id)
+        
+        # 연결 해제 알림
+        await connection_manager.broadcast_message({
+            "type": "user_disconnected",
+            "user_id": user_id,
+            "timestamp": datetime.now().isoformat()
+        }, exclude_user=user_id)
+
+async def generate_ai_response(content: str, user_id: str) -> str:
+    """AI 응답 생성 (간단한 예시)"""
+    try:
+        # 현재 모델로 응답 생성
+        response = await generate_sync(content, user_id)
+        return response.get("response", "죄송합니다. 응답을 생성할 수 없습니다.")
+    except Exception as e:
+        logger.error(f"❌ AI 응답 생성 실패: {e}")
+        return "죄송합니다. 응답을 생성할 수 없습니다."
+
+# WebSocket 상태 조회 엔드포인트
+@app.get("/ws/status")
+async def get_websocket_status():
+    """WebSocket 연결 상태 조회"""
+    return {
+        "active_connections": connection_manager.get_connection_count(),
+        "active_users": connection_manager.get_active_users(),
+        "sessions": list(connection_manager.session_connections.keys())
+    }
+
+# Celery 백그라운드 작업 엔드포인트
+@app.post("/tasks/document/process")
+async def start_document_processing(
+    user_id: str = Form(...),
+    document_id: str = Form(...),
+    file_path: str = Form(...),
+    file_type: str = Form(...)
+):
+    """문서 처리 백그라운드 작업 시작"""
+    try:
+        task = process_document_async.delay(user_id, document_id, file_path, file_type)
+        
+        return {
+            "success": True,
+            "task_id": task.id,
+            "status": "started",
+            "message": "문서 처리 작업이 시작되었습니다."
+        }
+    except Exception as e:
+        logger.error(f"❌ 문서 처리 작업 시작 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@app.post("/tasks/ai/generate")
+async def start_ai_generation(
+    user_id: str = Form(...),
+    session_id: str = Form(...),
+    prompt: str = Form(...),
+    model_id: Optional[str] = Form(None)
+):
+    """AI 응답 생성 백그라운드 작업 시작"""
+    try:
+        task = generate_ai_response_async.delay(user_id, session_id, prompt, model_id)
+        
+        return {
+            "success": True,
+            "task_id": task.id,
+            "status": "started",
+            "message": "AI 응답 생성 작업이 시작되었습니다."
+        }
+    except Exception as e:
+        logger.error(f"❌ AI 응답 생성 작업 시작 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@app.post("/tasks/rag/query")
+async def start_rag_query(
+    user_id: str = Form(...),
+    query: str = Form(...),
+    document_id: str = Form(...)
+):
+    """RAG 쿼리 백그라운드 작업 시작"""
+    try:
+        task = rag_query_async.delay(user_id, query, document_id)
+        
+        return {
+            "success": True,
+            "task_id": task.id,
+            "status": "started",
+            "message": "RAG 쿼리 작업이 시작되었습니다."
+        }
+    except Exception as e:
+        logger.error(f"❌ RAG 쿼리 작업 시작 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@app.post("/tasks/documents/batch")
+async def start_batch_processing(
+    user_id: str = Form(...),
+    document_ids: str = Form(...)  # JSON 문자열로 전달
+):
+    """문서 일괄 처리 백그라운드 작업 시작"""
+    try:
+        import json
+        doc_ids = json.loads(document_ids)
+        
+        task = batch_process_documents_async.delay(user_id, doc_ids)
+        
+        return {
+            "success": True,
+            "task_id": task.id,
+            "status": "started",
+            "message": f"문서 일괄 처리 작업이 시작되었습니다. ({len(doc_ids)}개 문서)"
+        }
+    except Exception as e:
+        logger.error(f"❌ 문서 일괄 처리 작업 시작 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@app.get("/tasks/{task_id}")
+async def get_task_status_endpoint(task_id: str):
+    """작업 상태 조회"""
+    try:
+        status = get_task_status(task_id)
+        
+        if status:
+            return {
+                "success": True,
+                "task_id": task_id,
+                "status": status["status"],
+                "result": status["result"],
+                "info": status["info"]
+            }
+        else:
+            return {
+                "success": False,
+                "error": "작업을 찾을 수 없습니다."
+            }
+    except Exception as e:
+        logger.error(f"❌ 작업 상태 조회 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@app.delete("/tasks/{task_id}")
+async def cancel_task_endpoint(task_id: str):
+    """작업 취소"""
+    try:
+        success = cancel_task(task_id)
+        
+        if success:
+            return {
+                "success": True,
+                "task_id": task_id,
+                "message": "작업이 취소되었습니다."
+            }
+        else:
+            return {
+                "success": False,
+                "error": "작업 취소에 실패했습니다."
+            }
+    except Exception as e:
+        logger.error(f"❌ 작업 취소 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+# 성능 모니터링 엔드포인트
+@app.post("/monitoring/start")
+async def start_performance_monitoring():
+    """성능 모니터링 시작"""
+    try:
+        performance_monitor.start_monitoring()
+        return {"message": "성능 모니터링이 시작되었습니다."}
+    except Exception as e:
+        logger.error(f"모니터링 시작 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"모니터링 시작 실패: {str(e)}")
+
+@app.post("/monitoring/stop")
+async def stop_performance_monitoring():
+    """성능 모니터링 중지"""
+    try:
+        performance_monitor.stop_monitoring()
+        return {"message": "성능 모니터링이 중지되었습니다."}
+    except Exception as e:
+        logger.error(f"모니터링 중지 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"모니터링 중지 실패: {str(e)}")
+
+@app.get("/monitoring/status")
+async def get_monitoring_status():
+    """모니터링 상태 조회"""
+    try:
+        summary = performance_monitor.get_performance_summary()
+        return summary
+    except Exception as e:
+        logger.error(f"모니��링 상태 조회 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"모니터링 상태 조회 실패: {str(e)}")
+
+@app.get("/monitoring/health")
+async def get_system_health():
+    """시스템 건강 상태 조회"""
+    try:
+        health = performance_monitor.get_system_health()
+        return {
+            "status": health.status,
+            "cpu_health": health.cpu_health,
+            "memory_health": health.memory_health,
+            "disk_health": health.disk_health,
+            "network_health": health.network_health,
+            "recommendations": health.recommendations
+        }
+    except Exception as e:
+        logger.error(f"시스템 건강 상태 조회 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"시스템 건강 상태 조회 실패: {str(e)}")
+
+@app.post("/monitoring/export")
+async def export_performance_metrics(file_path: str = "performance_metrics.json"):
+    """성능 메트릭 내보내기"""
+    try:
+        performance_monitor.export_metrics(file_path)
+        return {"message": f"성능 메트릭이 {file_path}에 저장되었습니다."}
+    except Exception as e:
+        logger.error(f"메트릭 내보내기 실패: {e}")
+        raise HTTPException(status_code=500, detail=f"메트릭 내보내기 실패: {str(e)}")
+
+# ============================================================================
+# 이미지 OCR 전용 API 엔드포인트 (기존 텍스트 기반 시스템과 완전히 분리)
+# ============================================================================
+
+@app.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:
+            import uuid
+            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 처리 및 벡터 스토어에 저장
+        result = image_rag_processor.process_and_store_image_document(
+            user_id, document_id, temp_file_path
+        )
+        
+        # 임시 파일 삭제
+        import os
+        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)
+        )
+
+@app.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 응답 생성
+        result = image_rag_processor.generate_image_rag_response(
+            user_id, document_id, query
+        )
+        
+        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
+        )
+
+@app.get("/image-ocr/document/{user_id}/{document_id}")
+async def get_image_document_info(user_id: str, document_id: str):
+    """이미지 OCR 문서 정보 조회"""
+    try:
+        result = image_rag_processor.get_image_document_info(user_id, document_id)
+        return result
+    except Exception as e:
+        logger.error(f"❌ 이미지 OCR 문서 정보 ���회 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@app.delete("/image-ocr/document/{user_id}/{document_id}")
+async def delete_image_document(user_id: str, document_id: str):
+    """이미지 OCR 문서 삭제"""
+    try:
+        # 벡터 스토어에서 문서 삭제
+        success = vector_store_manager.delete_document(user_id, document_id)
+        
+        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 엔드포인트 (수학 수식 인식 기능 포함)
+# ============================================================================
+
+@app.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:
+            import uuid
+            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 처리 및 벡터 스토어에 저장
+        result = latex_rag_processor.process_and_store_latex_document(
+            user_id, document_id, temp_file_path
+        )
+        
+        # 임시 파일 삭제
+        import os
+        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)
+        )
+
+@app.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 응답 생성
+        result = latex_rag_processor.generate_latex_rag_response(
+            user_id, document_id, query
+        )
+        
+        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
+        )
+
+@app.get("/latex-ocr/document/{user_id}/{document_id}")
+async def get_latex_document_info(user_id: str, document_id: str):
+    """LaTeX-OCR 문서 정보 조회"""
+    try:
+        result = latex_rag_processor.get_latex_document_info(user_id, document_id)
+        return result
+    except Exception as e:
+        logger.error(f"❌ LaTeX-OCR 문서 정보 조회 실패: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@app.delete("/latex-ocr/document/{user_id}/{document_id}")
+async def delete_latex_document(user_id: str, document_id: str):
+    """LaTeX-OCR 문서 삭제"""
+    try:
+        # 벡터 스토어에서 문서 삭제
+        success = vector_store_manager.delete_document(user_id, document_id)
+        
+        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 통합 시스템 엔드포인트
+# ============================================================================
+
+# LaTeX-OCR + FAISS 시스템 초기화
+latex_ocr_faiss_simple = None
+latex_ocr_faiss_integrated = None
+
+def init_latex_ocr_faiss_systems():
+    """LaTeX-OCR + FAISS 시스템 초기화"""
+    global latex_ocr_faiss_simple, latex_ocr_faiss_integrated
+    try:
+        latex_ocr_faiss_simple = LatexOCRFAISSSimple()
+        latex_ocr_faiss_integrated = LatexOCRFAISSIntegrated()
+        logger.info("✅ LaTeX-OCR + FAISS 시스템 초기화 완료")
+    except Exception as e:
+        logger.error(f"❌ LaTeX-OCR + FAISS 시스템 초기화 실패: {e}")
+
+@app.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:
+        # 파일 저장
+        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)
+        
+        # 시스템 선택
+        if system_type == "simple":
+            if not latex_ocr_faiss_simple:
+                init_latex_ocr_faiss_systems()
+            system = latex_ocr_faiss_simple
+        else:
+            if not latex_ocr_faiss_integrated:
+                init_latex_ocr_faiss_systems()
+            system = latex_ocr_faiss_integrated
+        
+        # PDF 처리
+        result = system.process_pdf_with_latex(str(file_path), user_id)
+        
+        if result["success"]:
+            return DocumentUploadResponse(
+                success=True,
+                document_id=f"latex_ocr_faiss_{user_id}_{file.filename}",
+                message=f"LaTeX 수식 {result['latex_count']}개 추출 완료",
+                chunks=result['latex_count'],
+                latex_count=result['latex_count']
+            )
+        else:
+            return DocumentUploadResponse(
+                success=False,
+                document_id="",
+                message="LaTeX 수식 추출 실패",
+                error=result.get("error", "LaTeX 수식 추출 실패")
+            )
+            
+    except Exception as e:
+        logger.error(f"LaTeX-OCR + FAISS 처리 오류: {e}")
+        return DocumentUploadResponse(
+            success=False,
+            document_id="",
+            message="처리 중 오류가 발생했습니다",
+            error=f"처리 중 오류가 발생했습니다: {str(e)}"
+        )
+
+@app.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:
+        # 시스템 선택
+        if system_type == "simple":
+            if not latex_ocr_faiss_simple:
+                init_latex_ocr_faiss_systems()
+            system = latex_ocr_faiss_simple
+        else:
+            if not latex_ocr_faiss_integrated:
+                init_latex_ocr_faiss_systems()
+            system = latex_ocr_faiss_integrated
+        
+        # 수식 검색
+        search_result = system.search_formulas(query, user_id, document_path, k)
+        
+        if search_result["success"]:
+            # 검색 결과를 응답 형식으로 변환
+            context = "\n".join([f"수식: {result['formula']} (유사도: {result['similarity']:.3f})" 
+                                for result in search_result['results']])
+            
+            sources = [{"formula": result['formula'], "similarity": result['similarity'], 
+                       "page": result.get('page', 1)} for result in search_result['results']]
+            
+            return RAGResponse(
+                success=True,
+                response=f"검색된 수식 {search_result['search_results']}개를 찾았습니다.",
+                context=context,
+                sources=sources,
+                search_results=search_result['search_results'],
+                processing_time=0.0  # 실제 처리 시간 측정 필요
+            )
+        else:
+            return RAGResponse(
+                success=False,
+                response="수식 검색에 실패했습니다.",
+                context="",
+                sources=[],
+                search_results=0,
+                processing_time=0.0,
+                error=search_result.get("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)
+        )
+
+@app.get("/latex-ocr-faiss/status")
+async def get_latex_ocr_faiss_status():
+    """LaTeX-OCR + FAISS 시스템 상태 확인"""
+    try:
+        simple_status = latex_ocr_faiss_simple is not None
+        integrated_status = latex_ocr_faiss_integrated is not None
+        
+        return {
+            "simple_system_initialized": simple_status,
+            "integrated_system_initialized": integrated_status,
+            "status": "ready" if (simple_status or integrated_status) else "not_initialized"
+        }
+    except Exception as e:
+        logger.error(f"상태 확인 오류: {e}")
+        return {"status": "error", "error": str(e)}
+
+# ============================================================================
+# 멀티모달 RAG 시스템 엔드포인트
+# ============================================================================
+
+@app.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)
+        
+        # 멀티모달 처리
+        result = hybrid_rag_processor.process_document_hybrid(str(file_path), user_id, document_id)
+        
+        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)}"
+        )
+
+@app.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(True),
+    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:
+        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
+        )
+        
+        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
+        )
+
+@app.get("/hybrid-rag/document/{user_id}/{document_id}")
+async def get_hybrid_document_info(user_id: str, document_id: str):
+    """멀티모달 RAG 문서 정보 조회"""
+    try:
+        result = hybrid_rag_processor.get_document_info(user_id, document_id)
+        return result
+    except Exception as e:
+        logger.error(f"멀티모달 RAG 문서 정보 조회 오류: {e}")
+        return {"success": False, "error": str(e)}
+
+@app.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": hybrid_rag_processor.latex_ocr_faiss_integrated is not None,
+            "status": "ready"
+        }
+    except Exception as e:
+        logger.error(f"멀티모달 RAG 상태 확인 오류: {e}")
+        return {"status": "error", "error": str(e)}
+
+# run_server_v2.py 에서 직접 실행 시 주석 처리
+# if __name__ == "__main__":
+#     uvicorn.run(
+#         app,
+#         host="0.0.0.0",
+#         port=8001,
+#         reload=False,
+#         log_level="info"
+#     )

lily_llm_api/models/__init__.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""
+모델 프로필 관리
+"""
+
+# from .polyglot_ko_1_3b import PolyglotKo13bProfile
+# from .dialogpt_medium import DialoGPTMediumProfile
+# from .kanana_1_5_2_1b_instruct import Kanana15V21bInstructProfile
+# from .kanana_nano_2_1b_instruct import KananaNano21bInstructProfile
+# from .mistral_7b_instruct import Mistral7bInstructProfile
+# from .polyglot_ko_5_8b import PolyglotKo58bProfile
+from .polyglot_ko_1_3b_chat import PolyglotKo13bChatProfile
+from .kanana_1_5_v_3b_instruct import Kanana15V3bInstructProfile
+from .polyglot_ko_5_8b_chat import PolyglotKo58bChatProfile
+
+# 사용 가능한 모델 프로필들
+AVAILABLE_MODELS = {
+    # "polyglot-ko-1.3b": PolyglotKo13bProfile,
+    # "dialogpt-medium": DialoGPTMediumProfile,    
+    # "kanana-1.5-2.1b-instruct": Kanana15V21bInstructProfile,
+    # "kanana-nano-2.1b-instruct": KananaNano21bInstructProfile,
+    # "mistral-7b-instruct": Mistral7bInstructProfile,
+    # "polyglot-ko-5.8b": PolyglotKo58bProfile,
+    "polyglot-ko-1.3b-chat": PolyglotKo13bChatProfile,
+    "kanana-1.5-v-3b-instruct": Kanana15V3bInstructProfile,
+    "polyglot-ko-5.8b-chat": PolyglotKo58bChatProfile,
+}
+
+def get_model_profile(model_id: str):
+    """모델 ID로 프로필 가져오기"""
+    if model_id not in AVAILABLE_MODELS:
+        raise ValueError(f"알 수 없는 모델 ID: {model_id}")
+    return AVAILABLE_MODELS[model_id]()
+
+def list_available_models():
+    """사용 가능한 모델 목록 반환"""
+    models = []
+    for model_id, profile_class in AVAILABLE_MODELS.items():
+        profile = profile_class()
+        model_info = profile.get_model_info()
+        models.append({
+            "model_id": model_id,
+            "name": model_info["display_name"],
+            "description": model_info["description"],
+            "language": model_info["language"],
+            "model_size": model_info["model_size"],
+            "multimodal": model_info.get("multimodal", False)
+        })
+    return models

lily_llm_api/models/dialogpt_medium.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+DialoGPT-medium 모델 프로필
+"""
+
+from typing import Dict, Any, Tuple
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import logging
+
+logger = logging.getLogger(__name__)
+
+class DialoGPTMediumProfile:
+    """DialoGPT-medium 모델 프로필"""
+    
+    def __init__(self):
+        self.model_name = "microsoft/DialoGPT-medium"
+        self.local_path = None  # 온라인에서 로드
+        self.display_name = "DialoGPT-medium"
+        self.description = "영어 대화형 모델 (774M)"
+        self.language = "en"
+        self.model_size = "774M"
+        
+    def load_model(self) -> Tuple[AutoModelForCausalLM, AutoTokenizer]:
+        """모델 로드"""
+        logger.info(f"📥 {self.display_name} 모델 로드 중...")
+        
+        try:
+            # 온라인에서 모델 로드
+            tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            model = AutoModelForCausalLM.from_pretrained(self.model_name)
+            
+            if tokenizer.pad_token is None:
+                tokenizer.pad_token = tokenizer.eos_token
+            
+            logger.info(f"✅ {self.display_name} 모델 로드 성공!")
+            return model, tokenizer
+            
+        except Exception as e:
+            logger.error(f"❌ {self.display_name} 모델 로드 실패: {e}")
+            raise
+    
+    def format_prompt(self, user_input: str) -> str:
+        """프롬프트 포맷팅"""
+        return f"User: {user_input}\nAssistant:"
+    
+    def extract_response(self, full_text: str, formatted_prompt: str) -> str:
+        """응답 추출"""
+        if "Assistant:" in full_text:
+            response = full_text.split("Assistant:")[-1].strip()
+        else:
+            if formatted_prompt in full_text:
+                response = full_text.replace(formatted_prompt, "").strip()
+            else:
+                response = full_text.strip()
+        
+        return response
+    
+    def get_generation_config(self) -> Dict[str, Any]:
+        """생성 설정"""
+        return {
+            "max_new_tokens": 50,
+            "temperature": 0.9,
+            "do_sample": True,
+            "top_k": 50,
+            "top_p": 0.95,
+            "repetition_penalty": 1.1,
+            "no_repeat_ngram_size": 3,
+            "pad_token_id": None,
+            "eos_token_id": None
+        }
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """모델 정보"""
+        return {
+            "model_name": self.model_name,
+            "display_name": self.display_name,
+            "description": self.description,
+            "language": self.language,
+            "model_size": self.model_size,
+            "local_path": self.local_path
+        }

lily_llm_api/models/kanana_1_5_2_1b_instruct.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Kanana 1.5 2.1B Instruct 모델 프로필
+"""
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from typing import Dict, Any, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+class Kanana15V21bInstructProfile:
+    """Kanana 1.5 2.1B Instruct 모델 프로필"""
+    
+    def __init__(self):
+        self.model_name = "kakaocorp/kanana-1.5-2.1b-instruct-2505"
+        self.local_path = "./lily_llm_core/models/kanana-1.5-2.1b-instruct"
+        self.display_name = "Kanana 1.5 2.1B Instruct"
+        self.description = "Kakao의 Kanana 1.5 2.1B Instruct 모델"
+        self.language = ["ko", "en"]
+        self.model_size = "2.1B"
+    
+    def load_model(self) -> Tuple[AutoModelForCausalLM, AutoTokenizer]:
+        """모델 로드"""
+        logger.info(f"📥 {self.display_name} 모델 로드 중...")
+        
+        try:
+            # 토크나이저 로드
+            tokenizer = AutoTokenizer.from_pretrained(
+                self.local_path,
+                trust_remote_code=True,
+                local_files_only=True
+            )
+            
+            # 모델 로드
+            model = AutoModelForCausalLM.from_pretrained(
+                self.local_path,
+                torch_dtype=torch.float32,
+                device_map="cpu",
+                low_cpu_mem_usage=True,
+                local_files_only=True
+            )
+            
+            # 토크나이저 설정
+            if tokenizer.pad_token is None:
+                tokenizer.pad_token = tokenizer.eos_token
+            if tokenizer.eos_token is None:
+                tokenizer.eos_token = "</s>"
+            
+            logger.info(f"✅ {self.display_name} 모델 로드 성공!")
+            return model, tokenizer
+            
+        except Exception as e:
+            logger.error(f"❌ {self.display_name} 모델 로드 실패: {e}")
+            raise
+    
+    def format_prompt(self, user_input: str) -> str:
+        """프롬프트 포맷팅"""
+        return f"<|im_start|>user\n{user_input}<|im_end|>\n<|im_start|>assistant\n"
+    
+    def extract_response(self, full_text: str, formatted_prompt: str) -> str:
+        """응답 추출"""
+        if "<|im_start|>assistant\n" in full_text:
+            response = full_text.split("<|im_start|>assistant\n")[-1]
+            if "<|im_end|>" in response:
+                response = response.split("<|im_end|>")[0]
+            return response.strip()
+        return full_text.strip()
+    
+    def get_generation_config(self) -> Dict[str, Any]:
+        """생성 설정"""
+        return {
+            "max_new_tokens": 512,
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "do_sample": True,
+            "repetition_penalty": 1.1,
+            "no_repeat_ngram_size": 3,
+            "pad_token_id": None,  # 토크나이저에서 설정됨
+            "eos_token_id": None,  # 토크나이저에서 설정됨
+        }
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """모델 정보"""
+        return {
+            "model_name": self.model_name,
+            "display_name": self.display_name,
+            "description": self.description,
+            "language": self.language,
+            "model_size": self.model_size,
+            "local_path": self.local_path
+        } 

lily_llm_api/models/kanana_1_5_v_3b_instruct.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""
+Kanana-1.5-v-3b-instruct 모            델 프로필 (단순 로딩 최종본)
+"""
+import sys
+from typing import Dict, Any, Tuple
+import torch
+import logging
+from transformers import AutoTokenizer
+
+logger = logging.getLogger(__name__)
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+class Kanana15V3bInstructProfile:
+    """Kanana-1.5-v-3b-instruct 모델 프로필"""
+    
+    def __init__(self):
+        # 환경 감지
+        self.is_local = self._detect_local_environment()
+        
+        # 모델 경로 설정
+        if self.is_local:
+            self.model_name = "gbrabbit/lily-math-model"  # 로컬에서도 HF 모델명 사용
+            self.local_path = "./lily_llm_core/models/kanana_1_5_v_3b_instruct"
+            self.display_name = "Kanana-1.5-v-3b-instruct (로컬)"
+        else:
+            self.model_name = "gbrabbit/lily-math-model"  # Hugging Face 모델 경로
+            self.local_path = "./lily_llm_core/models/kanana_1_5_v_3b_instruct"
+            self.display_name = "Kanana-1.5-v-3b-instruct (서버)"
+            
+        self.description = "카카오 멀티모달 모델 (3.6B) - Math RAG 특화"
+        self.language = "ko"
+        self.model_size = "3.6B"
+        self.multimodal = True
+        
+    def _detect_local_environment(self) -> bool:
+        """로컬 환경인지 감지"""
+        import os
+        
+        # 로컬 환경 감지 조건들
+        local_indicators = [
+            os.path.exists('.env'),
+            os.path.exists('../.env'),
+            os.path.exists('../../.env'),
+            os.getenv('IS_LOCAL') == 'true',
+            os.getenv('ENVIRONMENT') == 'local',
+            os.getenv('DOCKER_ENV') == 'local',
+            # Windows 경로 확인
+            os.path.exists('C:/Project/lily_generate_project/lily_generate_package/.env'),
+        ]
+        
+        is_local = any(local_indicators)
+        logger.info(f"🔍 환경 감지: {'로컬' if is_local else '서버'}")
+        return is_local
+        
+    def _load_environment_variables(self):
+        """환경변수를 로드합니다."""
+        import os
+        
+        try:
+            if self.is_local:
+                # 로컬 환경: .env 파일 로드
+                from dotenv import load_dotenv
+                
+                # 여러 경로에서 .env 파일 찾기
+                env_paths = [
+                    '.env',
+                    '../.env',
+                    '../../.env',
+                    'C:/Project/lily_generate_project/lily_generate_package/.env',
+                ]
+                
+                env_loaded = False
+                for env_path in env_paths:
+                    if os.path.exists(env_path):
+                        load_dotenv(env_path)
+                        logger.info(f"✅ 환경변수 로드됨: {env_path}")
+                        env_loaded = True
+                        break
+                
+                if not env_loaded:
+                    logger.warning("⚠️ .env 파일을 찾을 수 없습니다")
+            else:
+                # 서버 환경: 시스템 환경변수 사용
+                logger.info("🌐 서버 환경변수 사용")
+                
+        except ImportError:
+            logger.warning("⚠️ python-dotenv가 설치되지 않음")
+        except Exception as e:
+            logger.error(f"❌ 환경변수 로드 실패: {e}")
+            
+    def load_model(self) -> Tuple[Any, Any]:
+        """환경에 따라 모델을 로드합니다."""
+        logger.info(f"📥 {self.display_name} 모델 로드 중...")
+        
+        import os
+        from pathlib import Path
+        
+        # 환경변수 로딩
+        self._load_environment_variables()
+        
+        try:
+            # 1. 로컬 캐시 경로가 있는지 확인
+            local_model_path = Path(self.local_path)
+            use_local = local_model_path.exists() and any(local_model_path.iterdir())
+            
+            if use_local:
+                logger.info(f"🗂️ 로컬 모델 사용: {self.local_path}")
+                model_path = self.local_path
+                local_files_only = True
+                
+                # 로컬 모델의 경우 sys.path에 추가
+                if self.local_path not in sys.path:
+                    sys.path.insert(0, self.local_path)
+            else:
+                logger.info(f"🌐 Hugging Face Hub에서 다운로드: {self.model_name}")
+                model_path = self.model_name
+                local_files_only = False
+                
+            # 환경별 추가 설정
+            if self.is_local:
+                logger.info("🏠 로컬 환경 설정 적용")
+                # 로컬 환경에서는 추가 설정이 필요할 수 있음
+            else:
+                logger.info("☁️ 서버 환경 설정 적용")
+                # 서버 환경에서는 캐시 디렉토리 등 설정
+            
+            # 2. 토크나이��� 로드
+            tokenizer = AutoTokenizer.from_pretrained(
+                model_path,
+                trust_remote_code=True,
+                local_files_only=local_files_only,
+                cache_dir="/app/cache/transformers" if not use_local else None
+            )
+            logger.info(f"✅ 토크나이저 로드 완료 ({tokenizer.__class__.__name__})")
+            
+            # 3. 모델 로드
+            if use_local:
+                # 로컬 모델: 커스텀 모델링 클래스 사용
+                from modeling import KananaVForConditionalGeneration
+                model = KananaVForConditionalGeneration.from_pretrained(
+                    model_path,
+                    trust_remote_code=True,
+                    torch_dtype=torch.float16,
+                    local_files_only=True,
+                    low_cpu_mem_usage=True,
+                ).to(DEVICE)
+            else:
+                # Hugging Face Hub: 표준 AutoModel 사용
+                from transformers import AutoModelForCausalLM
+                model = AutoModelForCausalLM.from_pretrained(
+                    model_path,
+                    trust_remote_code=True,
+                    torch_dtype=torch.float16,
+                    cache_dir="/app/cache/transformers",
+                    low_cpu_mem_usage=True,
+                ).to(DEVICE)
+            
+            logger.info(f"✅ 모델 로드 완료 ({model.__class__.__name__})")
+            return model, tokenizer
+            
+        except Exception as e:
+            logger.error(f"❌ {self.display_name} 모델 로드 실패: {e}", exc_info=True)
+            if use_local and self.local_path in sys.path:
+                sys.path.remove(self.local_path)
+            raise 
+
+    def get_generation_config(self) -> Dict[str, Any]:
+        # 모델 파라미터 최적화 설정, max_new_tokens : 생성되는 텍스트 길이 최대값 (이미지 설명을 위해 증가)
+        return {"max_new_tokens": 256, "temperature": 0.7, "do_sample": True, "top_k": 40, "top_p": 0.9, "repetition_penalty": 1.1}
+
+    def extract_response(self, full_text: str, formatted_prompt: str = None, **kwargs) -> str:
+        """
+        다양한 응답 형식을 처리할 수 있는 더 똑똑한 응답 추출 함수
+        """
+        logger.info(f"--- 응답 추출 시작 ---")
+        logger.info(f"전체 생성 텍스트 (Raw): \n---\n{full_text}\n---")
+        
+        # 프롬프트가 제공된 경우 이를 제거
+        if formatted_prompt and formatted_prompt in full_text:
+            response = full_text.replace(formatted_prompt, "").strip()
+            logger.info(f"✅ 성공: 프롬프트 제거로 응답 추출")
+            logger.info(f"추출된 응답: {response}")
+            if response:  # 빈 문자열이 아닌 경우에만 반환
+                return response
+
+        # 1순위: 가장 정확한 특수 태그로 추출 시도
+        # 예: <|start_header_id|>assistant<|end_header_id|>안녕하세요...
+        # 또는 <|im_start|>assistant안녕하세요...
+        assistant_tags = [
+            "<|start_header_id|>assistant<|end_header_id|>", 
+            "<|im_start|>assistant", 
+            "assistant\n",
+            "assistant:"
+        ]
+        for tag in assistant_tags:
+            if tag in full_text:
+                parts = full_text.split(tag)
+                if len(parts) > 1:
+                    response = parts[-1].strip()
+                    # 추가 정리: 특수 토큰 제거
+                    response = response.replace("<|im_end|>", "").strip()
+                    logger.info(f"✅ 성공: '{tag}' 태그로 응답 추출")
+                    logger.info(f"추출된 응답: {response}")
+                    if response:  # 빈 문자열이 아닌 경우에만 반환
+                        return response
+
+        # 2순위: 간단한 키워드로 추출 시도
+        # 예: ... user 안녕하세요 assistant 안녕하세요 ...
+        if "assistant" in full_text:
+            parts = full_text.split("assistant")
+            if len(parts) > 1:
+                response = parts[-1].strip()
+                response = response.replace("<|im_end|>", "").strip()
+                logger.info("✅ 성공: 'assistant' 키워드로 응답 추출")
+                logger.info(f"추출된 응답: {response}")
+                if response:  # 빈 문자열이 아닌 경우에만 반환
+                    return response
+
+        # 3순위: 프롬프트가 없는 경우, 전체 텍스트에서 불필요한 부분 제거
+        clean_text = full_text.strip()
+        # 일반적인 프롬프트 패턴 제거 시도
+        patterns_to_remove = [
+            "<|im_start|>user\n",
+            "<|im_end|>",
+            "<image>",
+            "user\n",
+            "assistant\n"
+        ]
+        
+        for pattern in patterns_to_remove:
+            clean_text = clean_text.replace(pattern, "")
+        
+        clean_text = clean_text.strip()
+        
+        if clean_text and clean_text != full_text:
+            logger.info("✅ 성공: 패턴 제거로 응답 정리")
+            logger.info(f"정리된 응답: {clean_text}")
+            return clean_text
+
+        logger.warning("⚠️ 경고: 응답에서 assistant 부분을 찾지 못했습니다. 전체 텍스트를 반환합니다.")
+        logger.info(f"최종 반환 텍스트: {full_text}")
+        return full_text
+
+    def get_model_info(self) -> Dict[str, Any]:
+        return {"model_name": self.model_name, "display_name": self.display_name, "description": self.description, "language": self.language, "model_size": self.model_size, "local_path": self.local_path, "multimodal": self.multimodal}

lily_llm_api/models/kanana_nano_2_1b_instruct.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+Kanana Nano 2.1B Instruct 모델 프로필
+"""
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from typing import Dict, Any, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+class KananaNano21bInstructProfile:
+    """Kanana Nano 2.1B Instruct 모델 프로필"""
+    
+    def __init__(self):
+        self.model_name = "kakaocorp/kanana-nano-2.1b-instruct"
+        self.local_path = "./lily_llm_core/models/kanana-nano-2.1b-instruct"
+        self.display_name = "Kanana Nano 2.1B Instruct"
+        self.description = "Kakao의 Kanana Nano 2.1B Instruct 모델 (가장 작은 모델)"
+        self.language = ["ko", "en"]
+        self.model_size = "2.1B"
+    
+    def load_model(self) -> Tuple[AutoModelForCausalLM, AutoTokenizer]:
+        """모델 로드"""
+        logger.info(f"📥 {self.display_name} 모델 로드 중...")
+        
+        try:
+            # 토크나이저 로드
+            tokenizer = AutoTokenizer.from_pretrained(
+                self.local_path,
+                trust_remote_code=True,
+                local_files_only=True
+            )
+            
+            # 모델 로드
+            model = AutoModelForCausalLM.from_pretrained(
+                self.local_path,
+                torch_dtype=torch.float32,
+                device_map="cpu",
+                low_cpu_mem_usage=True,
+                local_files_only=True
+            )
+            
+            # 토크나이저 설정
+            if tokenizer.pad_token is None:
+                tokenizer.pad_token = tokenizer.eos_token
+            if tokenizer.eos_token is None:
+                tokenizer.eos_token = "</s>"
+            
+            logger.info(f"✅ {self.display_name} 모델 로드 성공!")
+            return model, tokenizer
+            
+        except Exception as e:
+            logger.error(f"❌ {self.display_name} 모델 로드 실패: {e}")
+            raise
+    
+    def format_prompt(self, user_input: str) -> str:
+        """프롬프트 포맷팅"""
+        return f"<|im_start|>user\n{user_input}<|im_end|>\n<|im_start|>assistant\n"
+    
+    def extract_response(self, full_text: str, formatted_prompt: str) -> str:
+        """응답 추출"""
+        if "<|im_start|>assistant\n" in full_text:
+            response = full_text.split("<|im_start|>assistant\n")[-1]
+            if "<|im_end|>" in response:
+                response = response.split("<|im_end|>")[0]
+            return response.strip()
+        return full_text.strip()
+    
+    def get_generation_config(self) -> Dict[str, Any]:
+        """생성 설정"""
+        return {
+            "max_new_tokens": 128,  # 512에서 128로 줄임
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "do_sample": True,
+            "repetition_penalty": 1.1,
+            "no_repeat_ngram_size": 3,
+            "pad_token_id": None,  # 토크나이저에서 설정됨
+            "eos_token_id": None,  # 토크나이저에서 설정됨
+            "use_cache": True,  # 캐시 사용
+            "return_dict_in_generate": False,  # 메모리 절약
+        }
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """모델 정보"""
+        return {
+            "model_name": self.model_name,
+            "display_name": self.display_name,
+            "description": self.description,
+            "language": self.language,
+            "model_size": self.model_size,
+            "local_path": self.local_path
+        } 

lily_llm_api/models/mistral_7b_instruct.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+Mistral-7B-Instruct-v0.2 모델 프로필
+mistralai/Mistral-7B-Instruct-v0.2 모델용
+"""
+
+from typing import Dict, Any, Tuple
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import logging
+
+logger = logging.getLogger(__name__)
+
+class Mistral7bInstructProfile:
+    """Mistral-7B-Instruct-v0.2 모델 프로필"""
+    
+    def __init__(self):
+        self.model_name = "mistralai/Mistral-7B-Instruct-v0.2"
+        self.local_path = "./lily_llm_core/models/mistral-7B-Instruct-v0.2"
+        self.display_name = "Mistral-7B-Instruct-v0.2"
+        self.description = "Mistral AI의 7B 파라미터 인스트럭트 모델"
+        self.language = "en"
+        self.model_size = "7B"
+        
+    def load_model(self) -> Tuple[AutoModelForCausalLM, AutoTokenizer]:
+        """모델 로드"""
+        logger.info(f"📥 {self.display_name} 모델 로드 중...")
+        
+        try:
+            # 로컬 모델 로드
+            tokenizer = AutoTokenizer.from_pretrained(self.local_path, use_fast=True)
+            
+            if tokenizer.pad_token is None:
+                tokenizer.pad_token = tokenizer.eos_token
+            
+            model = AutoModelForCausalLM.from_pretrained(
+                self.local_path,                
+                trust_remote_code=True,                
+                local_files_only=True,
+                torch_dtype=torch.bfloat16,
+                # device_map="cpu",
+                # low_cpu_mem_usage=True                
+                # max_memory={"cpu": "8GB"}
+            )
+            
+            # 모델을 CPU로 명시적 이동
+            model.to('cpu') 
+                        
+            logger.info(f"✅ {self.display_name} 모델 로드 성공!")
+            return model, tokenizer
+            
+        except Exception as e:
+            logger.error(f"❌ {self.display_name} 모델 로드 실패: {e}")
+            raise
+    
+    def format_prompt(self, user_input: str) -> str:
+        """프롬프트 포맷팅 - Mistral 인스트럭트 형식"""
+        # Mistral-7B-Instruct-v0.2 모델의 권장 프롬프트 형식
+        prompt = f"""<s>[INST] {user_input} [/INST]"""
+        return prompt
+    
+    def extract_response(self, full_text: str, formatted_prompt: str) -> str:
+        """응답 추출"""
+        # Mistral 모델의 응답 추출
+        if "[/INST]" in full_text:
+            response = full_text.split("[/INST]")[-1].strip()
+        else:
+            # 프롬프트 제거
+            if formatted_prompt in full_text:
+                response = full_text.replace(formatted_prompt, "").strip()
+            else:
+                response = full_text.strip()
+        
+        # 빈 응답이나 이상한 문자만 있는 경우 처리
+        if not response or len(response.strip()) < 2:
+            return "Hello! How can I help you today?"
+        
+        return response
+    
+    def get_generation_config(self) -> Dict[str, Any]:
+        """생성 설정"""
+        return {
+            "max_new_tokens": 128,
+            "temperature": 0.7,
+            "do_sample": True,
+            "top_k": 50,
+            "top_p": 0.9,
+            "repetition_penalty": 1.1,
+            "no_repeat_ngram_size": 3,
+            "pad_token_id": None,  # 모델에서 자동 설정
+            "eos_token_id": None   # 모델에서 자동 설정
+        }
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """모델 정보"""
+        return {
+            "model_name": self.model_name,
+            "display_name": self.display_name,
+            "description": self.description,
+            "language": self.language,
+            "model_size": self.model_size,
+            "local_path": self.local_path
+        }