feat: Parent Chunk 湲곕뒫 異붽? 諛?RAG ?쒖뒪??媛쒖꽑

- Parent Chunk ?앹꽦 湲곕뒫 異붽? (AI 遺꾩꽍: ?멸퀎愿€, 罹먮┃?? ?ㅽ넗由? ?먰뵾?뚮뱶, 湲고?)
- 2?④퀎 RAG 寃€???쒖뒪??援ы쁽 (Parent Chunk濡?臾몃㎘ ?뚯븙 + Child Chunk濡??뺣? 寃€??
- ?뚯씪 ??젣 ??Parent Chunk?€ Child Chunk 紐⑤몢 ??젣?섎룄濡?媛쒖꽑
- 愿€由??섏씠吏€?먯꽌 Parent Chunk ?댁슜 ?뺤씤 湲곕뒫 異붽?
- Ollama 404 ?ㅻ쪟 泥섎━ 媛쒖꽑 (紐⑤뜽 ?놁쓣 ??紐낇솗??硫붿떆吏€ ?쒓났)
- EXAONE 紐⑤뜽 愿€???ㅽ겕由쏀듃 諛?媛€?대뱶 臾몄꽌 異붽?
- ?ㅼ젣 ?ㅼ튂??紐⑤뜽留??쒖떆?섎룄濡?紐⑤뜽 紐⑸줉 API ?섏젙

EXAONE-3.0-7.8B-Instruct.modelfile

@@ -0,0 +1,22 @@
+FROM huggingface:LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct
+
+# 모델 설정
+PARAMETER temperature 0.7
+PARAMETER top_p 0.9
+PARAMETER top_k 40
+PARAMETER num_ctx 4096
+PARAMETER num_predict 512
+
+# 시스템 프롬프트
+SYSTEM """You are EXAONE, a helpful AI assistant developed by LG AI Research. 
+You are designed to be helpful, harmless, and honest. 
+You can communicate in both Korean and English."""
+
+# EXAONE 모델의 채팅 템플릿
+TEMPLATE """{{ if .System }}<|im_start|>system
+{{ .System }}<|im_end|>
+{{ end }}{{ if .Prompt }}<|im_start|>user
+{{ .Prompt }}<|im_end|>
+{{ end }}<|im_start|>assistant
+{{ .Response }}<|im_end|>
+"""

EXAONE_설치_가이드.md

@@ -0,0 +1,149 @@
+# EXAONE-3.0-7.8B-Instruct Ollama 설치 가이드
+
+Hugging Face의 EXAONE-3.0-7.8B-Instruct 모델을 Ollama에 추가하는 방법입니다.
+
+## 사전 준비
+
+### 1. Hugging Face 계정 및 액세스 권한
+
+1. [Hugging Face 계정 생성](https://huggingface.co/join) (없는 경우)
+2. [EXAONE-3.0-7.8B-Instruct 모델 페이지](https://huggingface.co/LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct) 방문
+3. 사용 조건에 동의하고 액세스 권한 요청
+
+### 2. Hugging Face 토큰 설정
+
+```bash
+# Hugging Face CLI로 로그인
+huggingface-cli login
+
+# 또는 환경 변수로 토큰 설정
+export HUGGINGFACE_HUB_TOKEN=your_token_here
+```
+
+Windows PowerShell:
+```powershell
+$env:HUGGINGFACE_HUB_TOKEN="your_token_here"
+```
+
+### 3. 필요한 패키지 설치
+
+```bash
+pip install huggingface_hub transformers torch
+```
+
+## 설치 방법
+
+### 방법 1: Ollama의 --from 옵션 사용 (가장 간단)
+
+```bash
+ollama create EXAONE-3.0-7.8B-Instruct --from huggingface:LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct
+```
+
+**주의사항:**
+- Ollama 최신 버전이 필요합니다 (0.1.0 이상)
+- 모델이 GGUF 형식으로 변환되어 있어야 합니다
+- Hugging Face에 GGUF 버전이 없으면 이 방법은 작동하지 않을 수 있습니다
+
+### 방법 2: Modelfile 사용 (권장)
+
+1. `add_exaone_model.py` 스크립트 실행:
+```bash
+python add_exaone_model.py
+```
+
+2. 생성된 Modelfile로 모델 생성:
+```bash
+ollama create EXAONE-3.0-7.8B-Instruct -f EXAONE-3.0-7.8B-Instruct.modelfile
+```
+
+### 방법 3: 수동 Modelfile 생성
+
+1. `EXAONE-3.0-7.8B-Instruct.modelfile` 파일 생성:
+
+```modelfile
+FROM huggingface:LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct
+
+PARAMETER temperature 0.7
+PARAMETER top_p 0.9
+PARAMETER top_k 40
+PARAMETER num_ctx 4096
+
+SYSTEM """You are EXAONE, a helpful AI assistant developed by LG AI Research."""
+
+TEMPLATE """{{ if .System }}<|im_start|>system
+{{ .System }}<|im_end|>
+{{ end }}{{ if .Prompt }}<|im_start|>user
+{{ .Prompt }}<|im_end|>
+{{ end }}<|im_start|>assistant
+{{ .Response }}<|im_end|>
+"""
+```
+
+2. 모델 생성:
+```bash
+ollama create EXAONE-3.0-7.8B-Instruct -f EXAONE-3.0-7.8B-Instruct.modelfile
+```
+
+### 방법 4: GGUF 변환 후 추가 (고급)
+
+Hugging Face 모델이 GGUF 형식이 아닌 경우, llama.cpp를 사용하여 변환해야 합니다.
+
+1. llama.cpp 설치 및 빌드
+2. 모델을 GGUF 형식으로 변환
+3. 변환된 모델을 Ollama에 추가
+
+자세한 내용은 [llama.cpp 문서](https://github.com/ggerganov/llama.cpp)를 참고하세요.
+
+## 설치 확인
+
+```bash
+# 모델 목록 확인
+ollama list
+
+# 모델 테스트
+ollama run EXAONE-3.0-7.8B-Instruct "안녕하세요"
+```
+
+## 문제 해결
+
+### 1. "file does not exist" 오류
+
+- Hugging Face 토큰이 올바르게 설정되었는지 확인
+- 모델 액세스 권한이 승인되었는지 확인
+- Ollama 버전이 최신인지 확인
+
+### 2. 모델이 너무 큼
+
+- 모델 크기는 약 15GB입니다
+- 충분한 디스크 공간과 메모리가 필요합니다
+- GPU 메모리 최소 16GB 권장
+
+### 3. 변환 오류
+
+- 모델이 GGUF 형식이 아닌 경우, llama.cpp로 변환 필요
+- 또는 Ollama의 최신 버전에서 Hugging Face 모델 직접 지원 여부 확인
+
+## 참고 자료
+
+- [EXAONE-3.0-7.8B-Instruct 모델 페이지](https://huggingface.co/LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct)
+- [Ollama 공식 문서](https://github.com/ollama/ollama)
+- [EXAONE 기술 보고서](https://www.lgresearch.ai/data/upload/tech_report/ko/EXAONE_3.0_Technical_Report.pdf)
+
+## 대안: 직접 Hugging Face 모델 사용
+
+Ollama에 추가하는 것이 어려운 경우, Python에서 직접 Hugging Face 모델을 사용할 수도 있습니다:
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model = AutoModelForCausalLM.from_pretrained(
+    "LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct",
+    torch_dtype=torch.bfloat16,
+    trust_remote_code=True,
+    device_map="auto"
+)
+tokenizer = AutoTokenizer.from_pretrained("LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct")
+```
+
+하지만 이 경우 Ollama API와 통합하려면 추가 작업이 필요합니다.
+

EXAONE_추가_안내.md

@@ -0,0 +1,66 @@
+# EXAONE-3.0-7.8B-Instruct Ollama 추가 안내
+
+현재 Ollama 버전(0.13.0)에서는 Hugging Face 모델을 직접 가져오는 기능이 제한적입니다.
+
+## 현재 상황
+
+- **Ollama 버전**: 0.13.0
+- **Hugging Face 토큰**: 설정 완료
+- **문제**: `FROM huggingface:` 프리픽스가 지원되지 않음
+
+## 해결 방법
+
+### 방법 1: Ollama 업데이트 (가장 권장)
+
+최신 버전의 Ollama는 Hugging Face 모델을 더 잘 지원합니다.
+
+1. [Ollama 다운로드 페이지](https://ollama.ai/download)에서 최신 버전 다운로드
+2. 설치 후 재시작
+3. 다음 명령어로 모델 추가 시도:
+
+```powershell
+$env:HUGGINGFACE_HUB_TOKEN="YOUR_HUGGINGFACE_TOKEN_HERE"
+ollama create EXAONE-3.0-7.8B-Instruct --from huggingface:LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct
+```
+
+### 방법 2: GGUF 형식 모델 사용
+
+EXAONE 모델의 GGUF 버전이 있다면:
+
+1. GGUF 모델 파일 다운로드
+2. 로컬 경로에 저장
+3. Modelfile 생성:
+
+```modelfile
+FROM /path/to/exaone-model.gguf
+PARAMETER temperature 0.7
+PARAMETER top_p 0.9
+```
+
+4. 모델 생성:
+```bash
+ollama create EXAONE-3.0-7.8B-Instruct -f Modelfile
+```
+
+### 방법 3: Python에서 직접 사용
+
+Ollama를 거치지 않고 Python에서 직접 Hugging Face 모델을 사용할 수 있습니다.
+하지만 이 경우 웹 애플리케이션과의 통합이 필요합니다.
+
+## 현재 설정된 정보
+
+- **Hugging Face 토큰**: `YOUR_HUGGINGFACE_TOKEN_HERE`
+- **모델 이름**: `LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct`
+- **생성된 Modelfile**: `EXAONE-3.0-7.8B-Instruct.modelfile`
+
+## 다음 단계
+
+1. Ollama를 최신 버전으로 업데이트
+2. 또는 EXAONE 모델의 GGUF 버전을 찾아서 사용
+3. 또는 Python에서 직접 모델을 사용하도록 애플리케이션 수정
+
+## 참고
+
+- [EXAONE 모델 페이지](https://huggingface.co/LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct)
+- [Ollama 공식 문서](https://github.com/ollama/ollama)
+

README.md

@@ -34,7 +34,21 @@ SOY NV AI/
 ├── venv/
 ├── requirements.txt
 ├── run.py
+├── add_exaone_model.py
+├── EXAONE_설치_가이드.md
 └── README.md
 ```
 
+## EXAONE-3.0-7.8B-Instruct 모델 추가
+
+Hugging Face의 EXAONE 모델을 Ollama에 추가하려면:
+
+1. `EXAONE_설치_가이드.md` 파일을 참고하세요
+2. 또는 `add_exaone_model.py` 스크립트를 실행하세요:
+   ```bash
+   python add_exaone_model.py
+   ```
+
+자세한 내용은 `EXAONE_설치_가이드.md`를 참고하세요.
+
 

add_exaone_model.py

@@ -0,0 +1,144 @@
+"""
+EXAONE-3.0-7.8B-Instruct 모델을 Ollama에 추가하는 스크립트
+
+사용 방법:
+1. Hugging Face에서 모델 액세스 권한을 받아야 합니다.
+2. 필요한 패키지를 설치합니다:
+   pip install transformers torch huggingface_hub
+3. 이 스크립트를 실행합니다:
+   python add_exaone_model.py
+"""
+
+import os
+import subprocess
+import json
+from pathlib import Path
+
+def create_ollama_modelfile():
+    """Ollama Modelfile 생성"""
+    # EXAONE 모델의 실제 채팅 템플릿 형식에 맞춰 수정
+    modelfile_content = """FROM huggingface:LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct
+
+# 모델 설정
+PARAMETER temperature 0.7
+PARAMETER top_p 0.9
+PARAMETER top_k 40
+PARAMETER num_ctx 4096
+PARAMETER num_predict 512
+
+# 시스템 프롬프트
+SYSTEM \"\"\"You are EXAONE, a helpful AI assistant developed by LG AI Research. 
+You are designed to be helpful, harmless, and honest. 
+You can communicate in both Korean and English.\"\"\"
+
+# EXAONE 모델의 채팅 템플릿 형식
+# 참고: 실제 모델의 토크나이저 템플릿을 확인하여 조정이 필요할 수 있습니다.
+TEMPLATE \"\"\"{{ if .System }}<|im_start|>system
+{{ .System }}<|im_end|>
+{{ end }}{{ if .Prompt }}<|im_start|>user
+{{ .Prompt }}<|im_end|>
+{{ end }}<|im_start|>assistant
+{{ .Response }}<|im_end|>
+\"\"\"
+"""
+    
+    modelfile_path = Path("EXAONE-3.0-7.8B-Instruct.modelfile")
+    modelfile_path.write_text(modelfile_content, encoding='utf-8')
+    print(f"✅ Modelfile 생성 완료: {modelfile_path}")
+    return modelfile_path
+
+def create_ollama_model_from_huggingface():
+    """Hugging Face 모델을 사용하여 Ollama 모델 생성"""
+    print("=" * 60)
+    print("EXAONE-3.0-7.8B-Instruct 모델을 Ollama에 추가합니다")
+    print("=" * 60)
+    
+    # 방법 1: Modelfile 사용 (권장)
+    print("\n[방법 1] Modelfile을 사용한 모델 생성")
+    print("-" * 60)
+    
+    modelfile_path = create_ollama_modelfile()
+    
+    print(f"\n다음 명령어를 실행하여 모델을 생성하세요:")
+    print(f"  ollama create EXAONE-3.0-7.8B-Instruct -f {modelfile_path}")
+    
+    # 방법 2: 직접 Hugging Face에서 가져오기
+    print("\n[방법 2] Hugging Face에서 직접 가져오기")
+    print("-" * 60)
+    print("다음 명령어를 실행하세요:")
+    print("  ollama create EXAONE-3.0-7.8B-Instruct --from huggingface:LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct")
+    
+    # 방법 3: Python 스크립트로 변환
+    print("\n[방법 3] GGUF 형식으로 변환 후 추가 (고급)")
+    print("-" * 60)
+    print("이 방법은 llama.cpp를 사용하여 모델을 GGUF 형식으로 변환한 후")
+    print("Ollama에 추가하는 방법입니다. 더 많은 설정이 필요합니다.")
+    
+    print("\n" + "=" * 60)
+    print("⚠️  중요 사항:")
+    print("=" * 60)
+    print("1. Hugging Face에서 모델 액세스 권한이 필요합니다.")
+    print("   https://huggingface.co/LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct")
+    print("2. Hugging Face 토큰이 필요할 수 있습니다.")
+    print("   환경 변수에 설정: export HUGGINGFACE_HUB_TOKEN=your_token")
+    print("   Windows PowerShell: $env:HUGGINGFACE_HUB_TOKEN='your_token'")
+    print("3. 모델 크기가 약 15GB이므로 충분한 디스크 공간이 필요합니다.")
+    print("4. GPU 메모리가 충분해야 합니다 (최소 16GB 권장).")
+    print("=" * 60)
+
+def check_ollama_installation():
+    """Ollama 설치 확인"""
+    try:
+        result = subprocess.run(['ollama', '--version'], 
+                              capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            print(f"✅ Ollama 설치 확인: {result.stdout.strip()}")
+            return True
+        else:
+            print("❌ Ollama가 설치되어 있지 않습니다.")
+            return False
+    except FileNotFoundError:
+        print("❌ Ollama가 설치되어 있지 않습니다.")
+        print("   설치 방법: https://ollama.ai/download")
+        return False
+    except Exception as e:
+        print(f"❌ Ollama 확인 중 오류: {e}")
+        return False
+
+def check_huggingface_access():
+    """Hugging Face 액세스 확인"""
+    try:
+        from huggingface_hub import whoami
+        user_info = whoami()
+        print(f"✅ Hugging Face 로그인 확인: {user_info.get('name', 'Unknown')}")
+        return True
+    except Exception as e:
+        print(f"⚠️  Hugging Face 로그인 확인 실패: {e}")
+        print("   Hugging Face CLI로 로그인하세요: huggingface-cli login")
+        return False
+
+if __name__ == "__main__":
+    print("\n" + "=" * 60)
+    print("EXAONE-3.0-7.8B-Instruct Ollama 추가 스크립트")
+    print("=" * 60 + "\n")
+    
+    # 사전 확인
+    ollama_ok = check_ollama_installation()
+    hf_ok = check_huggingface_access()
+    
+    if not ollama_ok:
+        print("\n⚠️  Ollama를 먼저 설치해주세요.")
+        exit(1)
+    
+    # 모델 추가 방법 안내
+    create_ollama_model_from_huggingface()
+    
+    print("\n" + "=" * 60)
+    print("다음 단계:")
+    print("=" * 60)
+    print("1. 위의 명령어 중 하나를 선택하여 실행하세요.")
+    print("2. 모델 생성이 완료되면 다음 명령어로 확인하세요:")
+    print("   ollama list")
+    print("3. 모델이 목록에 나타나면 웹 애플리케이션에서 사용할 수 있습니다.")
+    print("=" * 60 + "\n")
+

add_exaone_with_token.py

@@ -0,0 +1,176 @@
+"""
+EXAONE-3.0-7.8B-Instruct 모델을 Ollama에 추가하는 스크립트 (토큰 포함)
+"""
+
+import os
+import subprocess
+from pathlib import Path
+
+# Hugging Face 토큰
+HF_TOKEN = "YOUR_HUGGINGFACE_TOKEN_HERE"
+
+def set_huggingface_token():
+    """Hugging Face 토큰 설정"""
+    os.environ['HUGGINGFACE_HUB_TOKEN'] = HF_TOKEN
+    print(f"[OK] Hugging Face 토큰 설정 완료")
+
+def create_ollama_modelfile():
+    """Ollama Modelfile 생성"""
+    modelfile_content = f"""FROM huggingface:LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct
+
+# 모델 설정
+PARAMETER temperature 0.7
+PARAMETER top_p 0.9
+PARAMETER top_k 40
+PARAMETER num_ctx 4096
+PARAMETER num_predict 512
+
+# 시스템 프롬프트
+SYSTEM \"\"\"You are EXAONE, a helpful AI assistant developed by LG AI Research. 
+You are designed to be helpful, harmless, and honest. 
+You can communicate in both Korean and English.\"\"\"
+
+# EXAONE 모델의 채팅 템플릿
+TEMPLATE \"\"\"{{{{ if .System }}}}<|im_start|>system
+{{{{ .System }}}}<|im_end|>
+{{{{ end }}}}{{{{ if .Prompt }}}}<|im_start|>user
+{{{{ .Prompt }}}}<|im_end|>
+{{{{ end }}}}<|im_start|>assistant
+{{{{ .Response }}}}<|im_end|>
+\"\"\"
+"""
+    
+    modelfile_path = Path("EXAONE-3.0-7.8B-Instruct.modelfile")
+    modelfile_path.write_text(modelfile_content, encoding='utf-8')
+    print(f"[OK] Modelfile 생성 완료: {modelfile_path.absolute()}")
+    return modelfile_path
+
+def create_model_with_modelfile(modelfile_path):
+    """Modelfile을 사용하여 Ollama 모델 생성"""
+    try:
+        print("\n" + "=" * 60)
+        print("Ollama 모델 생성 시작...")
+        print("=" * 60)
+        
+        # 환경 변수 설정
+        env = os.environ.copy()
+        env['HUGGINGFACE_HUB_TOKEN'] = HF_TOKEN
+        
+        # ollama create 명령어 실행
+        cmd = ['ollama', 'create', 'EXAONE-3.0-7.8B-Instruct', '-f', str(modelfile_path)]
+        print(f"실행 명령어: {' '.join(cmd)}")
+        
+        result = subprocess.run(
+            cmd,
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=3600  # 1시간 타임아웃
+        )
+        
+        if result.returncode == 0:
+            print("[OK] 모델 생성 성공!")
+            print(result.stdout)
+            return True
+        else:
+            print("[ERROR] 모델 생성 실패")
+            print("오류 출력:")
+            print(result.stderr)
+            return False
+            
+    except subprocess.TimeoutExpired:
+        print("[ERROR] 모델 생성 시간 초과 (1시간)")
+        return False
+    except Exception as e:
+        print(f"[ERROR] 오류 발생: {e}")
+        return False
+
+def check_ollama_installation():
+    """Ollama 설치 확인"""
+    try:
+        result = subprocess.run(['ollama', '--version'], 
+                              capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            version = result.stdout.strip()
+            print(f"[OK] Ollama 설치 확인: {version}")
+            return True
+        else:
+            print("[ERROR] Ollama가 설치되어 있지 않습니다.")
+            return False
+    except FileNotFoundError:
+        print("[ERROR] Ollama가 설치되어 있지 않습니다.")
+        print("   설치 방법: https://ollama.ai/download")
+        return False
+    except Exception as e:
+        print(f"[ERROR] Ollama 확인 중 오류: {e}")
+        return False
+
+def verify_model():
+    """생성된 모델 확인"""
+    try:
+        result = subprocess.run(['ollama', 'list'], 
+                              capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            if 'EXAONE-3.0-7.8B-Instruct' in result.stdout:
+                print("\n[OK] 모델이 성공적으로 추가되었습니다!")
+                print("\n설치된 모델 목록:")
+                print(result.stdout)
+                return True
+            else:
+                print("\n[WARNING] 모델이 목록에 나타나지 않습니다.")
+                print("\n현재 설치된 모델:")
+                print(result.stdout)
+                return False
+        return False
+    except Exception as e:
+        print(f"[WARNING] 모델 확인 중 오류: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("\n" + "=" * 60)
+    print("EXAONE-3.0-7.8B-Instruct Ollama 추가 스크립트")
+    print("=" * 60 + "\n")
+    
+    # 사전 확인
+    if not check_ollama_installation():
+        print("\n[WARNING] Ollama를 먼저 설치해주세요.")
+        exit(1)
+    
+    # 토큰 설정
+    set_huggingface_token()
+    
+    # Modelfile 생성
+    modelfile_path = create_ollama_modelfile()
+    
+    # 모델 생성 확인
+    print("\n[WARNING] 주의사항:")
+    print("- 모델 크기가 약 15GB이므로 다운로드에 시간이 걸릴 수 있습니다.")
+    print("- 충분한 디스크 공간과 GPU 메모리가 필요합니다.")
+    print("- Hugging Face에서 모�� 액세스 권한이 필요합니다.")
+    
+    # 모델 생성 시작
+    print("\n모델 생성을 시작합니다...")
+    
+    # 모델 생성
+    success = create_model_with_modelfile(modelfile_path)
+    
+    if success:
+        verify_model()
+        print("\n" + "=" * 60)
+        print("[OK] 모델 추가 완료!")
+        print("=" * 60)
+        print("\n이제 웹 애플리케이션에서 모델을 사용할 수 있습니다.")
+        print("모델 테스트:")
+        print("  ollama run EXAONE-3.0-7.8B-Instruct \"안녕하세요\"")
+        print("=" * 60)
+    else:
+        print("\n" + "=" * 60)
+        print("[ERROR] 모델 생성 실패")
+        print("=" * 60)
+        print("\n수동으로 모델을 생성하려면:")
+        print(f"  1. Hugging Face 토큰 설정:")
+        print(f"     $env:HUGGINGFACE_HUB_TOKEN='{HF_TOKEN}'")
+        print(f"  2. Modelfile로 모델 생성:")
+        print(f"     ollama create EXAONE-3.0-7.8B-Instruct -f {modelfile_path}")
+        print("=" * 60)
+

app/database.py

@@ -49,6 +49,9 @@ class UploadedFile(db.Model):
     parent_file = db.relationship('UploadedFile', remote_side=[id], backref='child_files')
     
     def to_dict(self):
+        # 청크 개수 계산
+        chunk_count = len(self.chunks) if hasattr(self, 'chunks') else 0
+        
         return {
             'id': self.id,
             'filename': self.filename,
@@ -58,6 +61,7 @@ class UploadedFile(db.Model):
             'uploaded_at': self.uploaded_at.isoformat() if self.uploaded_at else None,
             'uploaded_by': self.uploaded_by,
             'parent_file_id': self.parent_file_id,
+            'chunk_count': chunk_count,
             'child_count': len(self.child_files) if self.child_files else 0
         }
 
@@ -123,4 +127,32 @@ class DocumentChunk(db.Model):
             'created_at': self.created_at.isoformat() if self.created_at else None
         }
 
+# Parent Chunk 모델 (AI 분석 결과 저장)
+class ParentChunk(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    file_id = db.Column(db.Integer, db.ForeignKey('uploaded_file.id'), nullable=False, unique=True)
+    world_view = db.Column(db.Text, nullable=True)  # 세계관 설명
+    characters = db.Column(db.Text, nullable=True)  # 주요 캐릭터 분석
+    story = db.Column(db.Text, nullable=True)  # 주요 스토리 분석
+    episodes = db.Column(db.Text, nullable=True)  # 주요 에피소드 분석
+    others = db.Column(db.Text, nullable=True)  # 기타
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+    
+    # 관계
+    file = db.relationship('UploadedFile', backref='parent_chunk')
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'file_id': self.file_id,
+            'world_view': self.world_view,
+            'characters': self.characters,
+            'story': self.story,
+            'episodes': self.episodes,
+            'others': self.others,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
 

app/routes.py

@@ -1,7 +1,7 @@
 from flask import Blueprint, render_template, request, jsonify, send_from_directory, redirect, url_for, flash
 from flask_login import login_user, logout_user, login_required, current_user
 from werkzeug.utils import secure_filename
-from app.database import db, UploadedFile, User, ChatSession, ChatMessage, DocumentChunk
+from app.database import db, UploadedFile, User, ChatSession, ChatMessage, DocumentChunk, ParentChunk
 import requests
 import os
 from datetime import datetime
@@ -179,33 +179,269 @@ def split_text_into_chunks(text, min_chunk_size=200, max_chunk_size=1000, overla
 def create_chunks_for_file(file_id, content):
     """파일 내용을 의미 기반 청크로 분할하여 저장"""
     try:
+        print(f"[청크 생성] 파일 ID {file_id}에 대한 청크 생성 시작")
+        print(f"[청크 생성] 원본 텍스트 길이: {len(content)}자")
+        
         # 기존 청크 삭제
-        DocumentChunk.query.filter_by(file_id=file_id).delete()
+        existing_chunks = DocumentChunk.query.filter_by(file_id=file_id).count()
+        if existing_chunks > 0:
+            print(f"[청크 생성] 기존 청크 {existing_chunks}개 삭제")
+            DocumentChunk.query.filter_by(file_id=file_id).delete()
+            db.session.commit()
         
         # 의미 기반 청킹 (문장과 문단 경계를 고려하여 분할)
         # min_chunk_size: 최소 200자, max_chunk_size: 최대 1000자, overlap: 150자
         chunks = split_text_into_chunks(content, min_chunk_size=200, max_chunk_size=1000, overlap=150)
+        print(f"[청크 생성] 분할된 청크 수: {len(chunks)}개")
+        
+        if len(chunks) == 0:
+            print(f"[청크 생성] 경고: 청크가 생성되지 않았습니다. 텍스트가 너무 짧거나 비어있을 수 있습니다.")
+            return 0
         
         # 각 청크를 데이터베이스에 저장
+        saved_count = 0
         for idx, chunk_content in enumerate(chunks):
-            chunk = DocumentChunk(
-                file_id=file_id,
-                chunk_index=idx,
-                content=chunk_content
-            )
-            db.session.add(chunk)
+            try:
+                chunk = DocumentChunk(
+                    file_id=file_id,
+                    chunk_index=idx,
+                    content=chunk_content
+                )
+                db.session.add(chunk)
+                saved_count += 1
+                
+                # 진행 상황 출력 (10개마다)
+                if (idx + 1) % 10 == 0:
+                    print(f"[청크 생성] 진행 중: {idx + 1}/{len(chunks)}개 청크 저장 중...")
+            except Exception as e:
+                print(f"[청크 생성] 경고: 청크 {idx} 저장 중 오류: {str(e)}")
+                continue
         
         db.session.commit()
-        return len(chunks)
+        print(f"[청크 생성] 완료: {saved_count}개 청크가 데이터베이스에 저장되었습니다.")
+        
+        # 저장 확인
+        verified_count = DocumentChunk.query.filter_by(file_id=file_id).count()
+        if verified_count != saved_count:
+            print(f"[청크 생성] 경고: 저장된 청크 수({saved_count})와 확인된 청크 수({verified_count})가 일치하지 않습니다.")
+        else:
+            print(f"[청크 생성] 검증 완료: {verified_count}개 청크가 정상적으로 저장되었습니다.")
+        
+        return saved_count
     except Exception as e:
         db.session.rollback()
-        print(f"청크 생성 오류: {str(e)}")
+        print(f"[청크 생성] 오류: {str(e)}")
         import traceback
         traceback.print_exc()
         return 0
 
+def create_parent_chunk_with_ai(file_id, content, model_name):
+    """AI를 사용하여 Parent Chunk 생성 (웹소설 분석)"""
+    try:
+        print(f"[Parent Chunk 생성] 파일 ID {file_id}에 대한 Parent Chunk 생성 시작")
+        print(f"[Parent Chunk 생성] 사용 모델: {model_name}")
+        print(f"[Parent Chunk 생성] 원본 텍스트 길이: {len(content)}자")
+        
+        # 텍스트가 너무 길면 일부만 사용 (최대 50000자)
+        content_preview = content[:50000] if len(content) > 50000 else content
+        if len(content) > 50000:
+            print(f"[Parent Chunk 생성] 텍스트가 길어 일부만 사용: {len(content_preview)}자 (전체: {len(content)}자)")
+        
+        # 분석 프롬프트 생성
+        analysis_prompt = f"""다음 웹소설 텍스트를 분석하여 다음 항목들을 작성해주세요. 각 항목은 명확하고 구체적으로 작성해주세요.
+
+텍스트 내용:
+{content_preview}
+
+위 텍스트를 분석하여 다음 형식으로 답변해주세요:
+
+## 세계관 설명
+[세계관에 대한 상세한 설명을 작성하세요. 배경, 설정, 규칙 등을 포함하세요.]
+
+## 주요 캐릭터 분석
+[주요 등장인물들의 이름, 역할, 성격, 특징 등을 분석하여 작성하세요. 각 캐릭터별로 구분하여 작성하세요.]
+
+## 주요 스토리 분석
+[전체적인 스토리 흐름, 주요 사건, 갈등 구조 등을 분석하여 작성하세요.]
+
+## 주요 에피소드 분석
+[중요한 에피소드나 챕터별 주요 내용을 분석하여 작성하세요. 시간 순서대로 정리하면 좋습니다.]
+
+## 기타
+[위 카테고리에 포함되지 않지만 중요한 정보나 특징 등을 작성하세요.]
+
+각 항목을 명확하게 구분하여 작성해주세요."""
+        
+        print(f"[Parent Chunk 생성] Ollama API에 분석 요청 전송 중...")
+        
+        # Ollama API 호출
+        ollama_response = requests.post(
+            f'{OLLAMA_BASE_URL}/api/chat',
+            json={
+                'model': model_name,
+                'messages': [
+                    {
+                        'role': 'user',
+                        'content': analysis_prompt
+                    }
+                ],
+                'stream': False
+            },
+            timeout=300  # 5분 타임아웃
+        )
+        
+        if ollama_response.status_code != 200:
+            error_detail = ollama_response.text if ollama_response.text else '상세 정보 없음'
+            if ollama_response.status_code == 404:
+                error_msg = f'Ollama API 오류 404: 모델 "{model_name}"을(를) 찾을 수 없습니다. 모델이 Ollama에 설치되어 있는지 확인하세요.'
+            else:
+                error_msg = f'Ollama API 오류: {ollama_response.status_code} - {error_detail[:200]}'
+            print(f"[Parent Chunk 생성] ❌ 오류: {error_msg}")
+            return None
+        
+        response_data = ollama_response.json()
+        analysis_result = response_data.get('message', {}).get('content', '')
+        
+        if not analysis_result:
+            print(f"[Parent Chunk 생성] ⚠️ 경고: 분석 결과가 비어있습니다.")
+            return None
+        
+        print(f"[Parent Chunk 생성] 분석 결과 수신 완료: {len(analysis_result)}자")
+        
+        # 분석 결과 파싱
+        world_view = ""
+        characters = ""
+        story = ""
+        episodes = ""
+        others = ""
+        
+        # 각 섹션 추출
+        sections = {
+            'world_view': ['## 세계관 설명', '## 세계관', '세계관 설명'],
+            'characters': ['## 주요 캐릭터 분석', '## 주요 캐릭터', '주요 캐릭터 분석', '## 캐릭터'],
+            'story': ['## 주요 스토리 분석', '## 주요 스토리', '주요 스토리 분석', '## 스토리'],
+            'episodes': ['## 주요 에피소드 분석', '## 주요 에피소드', '주요 에피소드 분석', '## 에피소드'],
+            'others': ['## 기타', '기타']
+        }
+        
+        lines = analysis_result.split('\n')
+        current_section = None
+        current_content = []
+        
+        for line in lines:
+            line_stripped = line.strip()
+            
+            # 섹션 헤더 확인
+            section_found = False
+            for section_key, section_headers in sections.items():
+                for header in section_headers:
+                    if header in line_stripped:
+                        # 이전 섹션 저장
+                        if current_section:
+                            if current_section == 'world_view':
+                                world_view = '\n'.join(current_content).strip()
+                            elif current_section == 'characters':
+                                characters = '\n'.join(current_content).strip()
+                            elif current_section == 'story':
+                                story = '\n'.join(current_content).strip()
+                            elif current_section == 'episodes':
+                                episodes = '\n'.join(current_content).strip()
+                            elif current_section == 'others':
+                                others = '\n'.join(current_content).strip()
+                        
+                        current_section = section_key
+                        current_content = []
+                        section_found = True
+                        break
+                
+                if section_found:
+                    break
+            
+            if not section_found and current_section:
+                # 현재 섹션에 내용 추가
+                if line_stripped and not line_stripped.startswith('#'):
+                    current_content.append(line)
+        
+        # 마지막 섹션 저장
+        if current_section:
+            if current_section == 'world_view':
+                world_view = '\n'.join(current_content).strip()
+            elif current_section == 'characters':
+                characters = '\n'.join(current_content).strip()
+            elif current_section == 'story':
+                story = '\n'.join(current_content).strip()
+            elif current_section == 'episodes':
+                episodes = '\n'.join(current_content).strip()
+            elif current_section == 'others':
+                others = '\n'.join(current_content).strip()
+        
+        # 파싱 실패 시 전체 내용을 "기타"에 저장
+        if not world_view and not characters and not story and not episodes:
+            print(f"[Parent Chunk 생성] 경고: 섹션 파싱 실패. 전체 내용을 '기타'에 저장합니다.")
+            others = analysis_result.strip()
+        
+        # 기존 Parent Chunk 삭제 (있으면)
+        existing_parent = ParentChunk.query.filter_by(file_id=file_id).first()
+        if existing_parent:
+            db.session.delete(existing_parent)
+            db.session.commit()
+            print(f"[Parent Chunk 생성] 기존 Parent Chunk 삭제 완료")
+        
+        # Parent Chunk 생성 및 저장
+        parent_chunk = ParentChunk(
+            file_id=file_id,
+            world_view=world_view if world_view else None,
+            characters=characters if characters else None,
+            story=story if story else None,
+            episodes=episodes if episodes else None,
+            others=others if others else None
+        )
+        
+        db.session.add(parent_chunk)
+        db.session.commit()
+        
+        print(f"[Parent Chunk 생성] ✅ 완료: Parent Chunk가 생성되었습니다.")
+        print(f"[Parent Chunk 생성] - 세계관: {len(world_view)}자")
+        print(f"[Parent Chunk 생성] - 캐릭터: {len(characters)}자")
+        print(f"[Parent Chunk 생성] - 스토리: {len(story)}자")
+        print(f"[Parent Chunk 생성] - 에피소드: {len(episodes)}자")
+        print(f"[Parent Chunk 생성] - 기타: {len(others)}자")
+        
+        return parent_chunk
+        
+    except requests.exceptions.RequestException as e:
+        error_msg = f'Ollama API 연결 오류: {str(e)}'
+        print(f"[Parent Chunk 생성] ❌ 오류: {error_msg}")
+        import traceback
+        traceback.print_exc()
+        return None
+    except Exception as e:
+        db.session.rollback()
+        error_msg = f'Parent Chunk 생성 중 오류: {str(e)}'
+        print(f"[Parent Chunk 생성] ❌ 오류: {error_msg}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+def get_parent_chunks_for_files(file_ids):
+    """파일 ID 목록에 대한 Parent Chunk 조회 (문맥 파악용)"""
+    try:
+        if not file_ids:
+            return []
+        
+        parent_chunks = []
+        for file_id in file_ids:
+            parent_chunk = ParentChunk.query.filter_by(file_id=file_id).first()
+            if parent_chunk:
+                parent_chunks.append(parent_chunk)
+        
+        return parent_chunks
+    except Exception as e:
+        print(f"[Parent Chunk 조회] 오류: {str(e)}")
+        return []
+
 def search_relevant_chunks(query, file_ids=None, model_name=None, top_k=25, min_score=1):
-    """질문과 관련된 청크 검색 (개선된 키워드 기반 검색)"""
+    """질문과 관련된 청크 검색 (개선된 키워드 기반 검색) - Child Chunk 정밀 검색"""
     try:
         # 검색 쿼리 준비 - 한글과 영문 단어 모두 추출
         query_words = set(re.findall(r'[가-힣]+|\w+', query.lower()))
@@ -527,13 +763,15 @@ def delete_user(user_id):
 @main_bp.route('/api/ollama/models', methods=['GET'])
 @login_required
 def get_ollama_models():
-    """Ollama에서 사용 가능한 모델 목록 가져오기"""
+    """Ollama에서 사용 가능한 모델 목록 가져오기 (실제 설치된 모델만 반환)"""
     try:
         response = requests.get(f'{OLLAMA_BASE_URL}/api/tags', timeout=5)
         if response.status_code == 200:
             data = response.json()
-            models = [{'name': model['name']} for model in data.get('models', [])]
-            return jsonify({'models': models})
+            ollama_models = [{'name': model['name']} for model in data.get('models', [])]
+            
+            # 실제 설치된 모델만 반환
+            return jsonify({'models': ollama_models})
         else:
             return jsonify({'error': 'Ollama 서버에 연결할 수 없습니다.', 'models': []}), 500
     except requests.exceptions.ConnectionError:
@@ -565,23 +803,60 @@ def chat():
                 use_rag = True  # RAG 사용 여부
                 
                 if use_rag:
-                    # 관련 청크 검색
                     print(f"\n[RAG 검색] 모델: {model}, 질문: {message[:50]}...")
                     print(f"[RAG 검색] 선택된 파일 ID: {file_ids if file_ids else '없음 (모든 파일 검색)'}")
                     
-                    # 더 많은 청크를 검색하도록 top_k 증가 (기본 25개)
+                    # 1단계: Parent Chunk로 문맥 파악
+                    parent_chunks = []
+                    if file_ids:
+                        print(f"[RAG 검색 1단계] Parent Chunk 조회 시작...")
+                        parent_chunks = get_parent_chunks_for_files(file_ids)
+                        print(f"[RAG 검색 1단계] Parent Chunk 조회 완료: {len(parent_chunks)}개 파일")
+                    
+                    # 2단계: Child Chunk로 정밀 검색
+                    print(f"[RAG 검색 2단계] Child Chunk 정밀 검색 시작...")
                     relevant_chunks = search_relevant_chunks(
                         query=message,
                         file_ids=file_ids if file_ids else None,
                         model_name=model,
-                        top_k=25,  # 5개에서 25개로 증가
-                        min_score=0.5  # 최소 점수 임계값 낮춤 (더 많은 청크 포함)
+                        top_k=25,  # 25개 청크 검색
+                        min_score=0.5  # 최소 점수 임계값
                     )
+                    print(f"[RAG 검색 2단계] Child Chunk 검색 완료: {len(relevant_chunks)}개 청크")
                     
-                    print(f"[RAG 검색] 검색된 청크 수: {len(relevant_chunks)}")
+                    # 컨텍스트 구성
+                    context_parts = []
                     
+                    # Parent Chunk 정보 추가 (문맥 파악용)
+                    if parent_chunks:
+                        parent_context_sections = []
+                        for parent_chunk in parent_chunks:
+                            file = parent_chunk.file
+                            file_info = f"\n=== {file.original_filename} 전체 개요 ===\n"
+                            
+                            sections = []
+                            if parent_chunk.world_view:
+                                sections.append(f"[세계관]\n{parent_chunk.world_view}")
+                            if parent_chunk.characters:
+                                sections.append(f"[주요 캐릭터]\n{parent_chunk.characters}")
+                            if parent_chunk.story:
+                                sections.append(f"[주요 스토리]\n{parent_chunk.story}")
+                            if parent_chunk.episodes:
+                                sections.append(f"[주요 에피소드]\n{parent_chunk.episodes}")
+                            if parent_chunk.others:
+                                sections.append(f"[기타 정보]\n{parent_chunk.others}")
+                            
+                            if sections:
+                                parent_context_sections.append(file_info + "\n\n".join(sections))
+                        
+                        if parent_context_sections:
+                            parent_context = "\n\n".join(parent_context_sections)
+                            context_parts.append(f"다음은 웹소설의 전체적인 문맥과 개요입니다:\n\n{parent_context}")
+                            print(f"[RAG 검색] Parent Chunk 컨텍스트 추가: {len(parent_context)}자")
+                    
+                    # Child Chunk 정보 추가 (정밀 검색 결과)
                     if relevant_chunks:
-                        context_parts = []
+                        child_context_parts = []
                         seen_files = set()
                         
                         for chunk in relevant_chunks:
@@ -590,28 +865,68 @@ def chat():
                                 seen_files.add(file.original_filename)
                                 print(f"[RAG 검색] 사용된 파일: {file.original_filename} (모델: {file.model_name})")
                             
-                            context_parts.append(f"[{file.original_filename} - 청크 {chunk.chunk_index + 1}]\n{chunk.content}")
+                            child_context_parts.append(f"[{file.original_filename} - 청크 {chunk.chunk_index + 1}]\n{chunk.content}")
                         
-                        if context_parts:
+                        if child_context_parts:
                             # 컨텍스트 길이 확인 및 최적화
-                            full_context = "\n\n".join(context_parts)
-                            context_length = len(full_context)
+                            full_child_context = "\n\n".join(child_context_parts)
+                            child_context_length = len(full_child_context)
                             
-                            # 컨텍스트가 너무 길면 일부만 사용 (최대 15000자)
-                            if context_length > 15000:
-                                # 상위 점수 청크 우선 유지하면서 길이 조절
+                            # Child Chunk 컨텍스트가 너무 길면 일부만 사용 (최대 15000자)
+                            if child_context_length > 15000:
                                 truncated_parts = []
                                 current_length = 0
-                                for part in context_parts:
+                                for part in child_context_parts:
                                     if current_length + len(part) > 15000:
                                         break
                                     truncated_parts.append(part)
                                     current_length += len(part)
-                                full_context = "\n\n".join(truncated_parts)
-                                print(f"[RAG 검색] 컨텍스트 길이 조절: {context_length}자 → {len(full_context)}자")
+                                full_child_context = "\n\n".join(truncated_parts)
+                                print(f"[RAG 검색] Child Chunk 컨텍스트 길이 조절: {child_context_length}자 → {len(full_child_context)}자")
                             
-                            context = f"다음은 질문과 관련된 웹소설 내용입니다 (RAG 검색 결과, 총 {len(relevant_chunks)}개 청크):\n\n{full_context}\n\n위 내용을 충분히 참고하여 다음 질문에 정확하고 상세하게 답변해주세요. 웹소설의 맥락과 스토리를 고려하여 답변해주세요:\n\n"
-                            print(f"[RAG 검색] 컨텍스트 생성 완료 ({len(seen_files)}개 파일, {len(relevant_chunks)}개 청크, {len(full_context)}자)")
+                            context_parts.append(f"다음은 질문과 관련된 웹소설의 구체적인 내용입니다 (정밀 검색 결과, 총 {len(relevant_chunks)}개 청크):\n\n{full_child_context}")
+                            print(f"[RAG 검색] Child Chunk 컨텍스트 추가: {len(full_child_context)}자")
+                    
+                    # 최종 컨텍스트 구성
+                    if context_parts:
+                        full_context = "\n\n" + "\n\n---\n\n".join(context_parts) + "\n\n"
+                        
+                        # Parent Chunk와 Child Chunk 모두 있는 경우
+                        if parent_chunks and relevant_chunks:
+                            context = f"""다음은 질문에 답하기 위한 웹소설 정보입니다:
+
+{full_context}
+
+위 정보를 참고하여 답변해주세요:
+- 먼저 전체적인 문맥(Parent Chunk)을 이해하여 웹소설의 배경과 설정을 파악하세요.
+- 그 다음 구체적인 내용(Child Chunk)을 통해 질문에 대한 정확한 답변을 제공하세요.
+- 웹소설의 맥락과 스토리를 고려하여 일관성 있는 답변을 작성하세요.
+
+질문:
+"""
+                        elif parent_chunks:
+                            # Parent Chunk만 있는 경우
+                            context = f"""다음은 웹소설의 전체적인 문맥과 개요입니다:
+
+{full_context}
+
+위 정보를 참고하여 질문에 답변해주세요. 웹소설의 배경과 설정을 고려하여 답변하세요.
+
+질문:
+"""
+                        else:
+                            # Child Chunk만 있는 경우
+                            context = f"""다음은 질문과 관련된 웹소설의 구체적인 내용입니다:
+
+{full_context}
+
+위 내용을 충분히 참고하여 다음 질문에 정확하고 상세하게 답변해주세요. 웹소설의 맥락과 스토리를 고려하여 답변해주세요:
+
+질문:
+"""
+                        
+                        context += message
+                        print(f"[RAG 검색] 최종 컨텍스트 생성 완료 (Parent Chunk: {len(parent_chunks)}개, Child Chunk: {len(relevant_chunks)}개, 총 {len(context)}자)")
                     else:
                         # RAG 검색 결과가 없으면 기존 방식 사용
                         print(f"[RAG 검색] 관련 청크를 찾지 못했습니다. 전체 파일 내용 사용")
@@ -763,7 +1078,18 @@ def chat():
                     
                     return jsonify(response_data)
                 else:
-                    error_msg = f'Ollama 서버 오류: {ollama_response.status_code}'
+                    # 오류 상세 정보 가져오기
+                    try:
+                        error_detail = ollama_response.json().get('error', ollama_response.text[:200])
+                    except:
+                        error_detail = ollama_response.text[:200] if ollama_response.text else '상세 정보 없음'
+                    
+                    if ollama_response.status_code == 404:
+                        error_msg = f'모델 "{model}"을(를) 찾을 수 없습니다. 모델이 Ollama에 설치되어 있는지 확인하세요. (오류: {error_detail})'
+                    else:
+                        error_msg = f'Ollama 서버 오류 {ollama_response.status_code}: {error_detail}'
+                    
+                    print(f"[채팅 API] 오류 발생: {error_msg}")
                     return jsonify({'error': error_msg}), ollama_response.status_code
                     
             except requests.exceptions.ConnectionError:
@@ -971,33 +1297,65 @@ def upload_file():
             # 텍스트 파일인 경우 청크로 분할하여 저장 (RAG용)
             if original_filename.lower().endswith(('.txt', '.md')):
                 try:
-                    print(f"텍스트 파일 청크 분할 시작: {original_filename}")
+                    log_print(f"[7/8] 청크 생성 시작: {original_filename}")
+                    log_print(f"[7/8] 파일 ID: {uploaded_file.id}")
+                    
+                    # 파일 내용 읽기
                     encoding = 'utf-8'
                     try:
                         with open(file_path, 'r', encoding=encoding) as f:
                             content = f.read()
+                        log_print(f"[7/8] UTF-8 인코딩으로 파일 읽기 성공: {len(content)}자")
                     except UnicodeDecodeError:
-                        print(f"UTF-8 인코딩 실패, CP949 시도: {original_filename}")
+                        log_print(f"[7/8] UTF-8 인코딩 실패, CP949 시도: {original_filename}")
                         with open(file_path, 'r', encoding='cp949') as f:
                             content = f.read()
+                        log_print(f"[7/8] CP949 인코딩으로 파일 읽기 성공: {len(content)}자")
                     
+                    # 청크 생성 및 저장
+                    log_print(f"[7/8] 청크 생성 함수 호출 중...")
                     chunk_count = create_chunks_for_file(uploaded_file.id, content)
+                    
                     if chunk_count > 0:
+                        log_print(f"[7/8] ✅ 성공: 파일 {original_filename}을 {chunk_count}개의 청크로 분할했습니다.")
                         print(f"파일 {original_filename}을 {chunk_count}개의 청크로 분할했습니다.")
+                    else:
+                        log_print(f"[7/8] ⚠️ 경고: 청크가 생성되지 않았습니다. (파일이 너무 짧거나 비어있을 수 있습니다.)")
+                        print(f"경고: 파일 {original_filename}에 대한 청크가 생성되지 않았습니다.")
+                    
+                    # Parent Chunk 생성 (AI 분석)
+                    log_print(f"[7/9] Parent Chunk 생성 시작 (AI 분석)...")
+                    parent_chunk = create_parent_chunk_with_ai(uploaded_file.id, content, model_name)
+                    if parent_chunk:
+                        log_print(f"[7/9] ✅ Parent Chunk 생성 완료: {original_filename}")
+                        print(f"Parent Chunk가 생성되었습니다: {original_filename}")
+                    else:
+                        log_print(f"[7/9] ⚠️ 경고: Parent Chunk 생성 실패: {original_filename}")
+                        print(f"경고: Parent Chunk 생성에 실패했습니다: {original_filename}")
+                    
                 except Exception as e:
-                    print(f"청크 생성 중 오류 (무시): {str(e)}")
+                    error_msg = f"청크 생성 중 오류: {str(e)}"
+                    log_print(f"[7/8] ❌ 오류: {error_msg}")
+                    print(error_msg)
                     import traceback
                     traceback.print_exc()
             
-            # 청크 개수 저장
+            # 최종 청크 개수 확인 및 저장
             chunk_count = 0
             if original_filename.lower().endswith(('.txt', '.md')):
                 chunk_count = DocumentChunk.query.filter_by(file_id=uploaded_file.id).count()
+                log_print(f"[8/8] 최종 청크 개수 확인: {chunk_count}개")
             
             db.session.commit()
             log_print(f"[8/8] 데이터베이스 커밋 완료: {original_filename}")
             log_print(f"[8/8] 연결된 모델: {model_name}")
             log_print(f"[8/8] 생성된 청크 수: {chunk_count}")
+            
+            # 학습 상태 요약
+            if chunk_count > 0:
+                log_print(f"[8/8] ✅ AI 학습 준비 완료: {chunk_count}개 청크가 저장되어 RAG 검색에 사용 가능합니다.")
+            else:
+                log_print(f"[8/8] ⚠️ 경고: 청크가 생성되지 않아 RAG 검색이 불가능합니다.")
             log_print(f"{'='*60}")
             log_print(f"=== 파일 업로드 성공 ===")
             log_print(f"{'='*60}\n")
@@ -1058,9 +1416,19 @@ def get_files():
         files_with_children = []
         for file in files:
             file_dict = file.to_dict()
+            # 청크 개수 추가
+            chunk_count = DocumentChunk.query.filter_by(file_id=file.id).count()
+            file_dict['chunk_count'] = chunk_count
+            
             # 이어서 업로드된 파일들도 조회
             child_files = UploadedFile.query.filter_by(parent_file_id=file.id).order_by(UploadedFile.uploaded_at.asc()).all()
-            file_dict['child_files'] = [child.to_dict() for child in child_files]
+            child_files_dict = []
+            for child in child_files:
+                child_dict = child.to_dict()
+                child_chunk_count = DocumentChunk.query.filter_by(file_id=child.id).count()
+                child_dict['chunk_count'] = child_chunk_count
+                child_files_dict.append(child_dict)
+            file_dict['child_files'] = child_files_dict
             files_with_children.append(file_dict)
         
         # 모델별 통계 정보 추가 (원본 파일만 카운트)
@@ -1092,6 +1460,70 @@ def get_files():
     except Exception as e:
         return jsonify({'error': f'파일 목록 조회 중 오류가 발생했습니다: {str(e)}'}), 500
 
+@main_bp.route('/api/files/<int:file_id>/chunks', methods=['GET'])
+@login_required
+def get_file_chunks(file_id):
+    """파일의 청크 정보 조회 (학습 상태 확인용)"""
+    try:
+        file = UploadedFile.query.filter_by(id=file_id, uploaded_by=current_user.id).first()
+        if not file:
+            return jsonify({'error': '파일을 찾을 수 없습니다.'}), 404
+        
+        chunks = DocumentChunk.query.filter_by(file_id=file_id).order_by(DocumentChunk.chunk_index.asc()).all()
+        total_chunks = len(chunks)
+        
+        # 샘플 청크 (처음 3개)
+        sample_chunks = []
+        for chunk in chunks[:3]:
+            sample_chunks.append({
+                'index': chunk.chunk_index,
+                'content_preview': chunk.content[:100] + '...' if len(chunk.content) > 100 else chunk.content,
+                'content_length': len(chunk.content)
+            })
+        
+        return jsonify({
+            'file_id': file_id,
+            'filename': file.original_filename,
+            'model_name': file.model_name,
+            'total_chunks': total_chunks,
+            'sample_chunks': sample_chunks,
+            'learning_status': 'ready' if total_chunks > 0 else 'not_ready',
+            'message': f'{total_chunks}개 청크가 저장되어 RAG 검색에 사용 가능합니다.' if total_chunks > 0 else '청크가 생성되지 않아 RAG 검색이 불가능합니다.'
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'청크 정보 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/files/<int:file_id>/parent-chunk', methods=['GET'])
+@login_required
+def get_file_parent_chunk(file_id):
+    """파일의 Parent Chunk 조회"""
+    try:
+        file = UploadedFile.query.filter_by(id=file_id, uploaded_by=current_user.id).first()
+        if not file:
+            return jsonify({'error': '파일을 찾을 수 없습니다.'}), 404
+        
+        parent_chunk = ParentChunk.query.filter_by(file_id=file_id).first()
+        
+        if not parent_chunk:
+            return jsonify({
+                'file_id': file_id,
+                'filename': file.original_filename,
+                'has_parent_chunk': False,
+                'message': 'Parent Chunk가 생성되지 않았습니다.'
+            }), 200
+        
+        return jsonify({
+            'file_id': file_id,
+            'filename': file.original_filename,
+            'has_parent_chunk': True,
+            'parent_chunk': parent_chunk.to_dict(),
+            'message': 'Parent Chunk가 존재합니다.'
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'Parent Chunk 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
 @main_bp.route('/api/files/<int:file_id>', methods=['DELETE'])
 @login_required
 def delete_file(file_id):
@@ -1127,15 +1559,28 @@ def delete_file(file_id):
                 # 파일 시스템에서 삭제
                 if os.path.exists(file_to_delete.file_path):
                     os.remove(file_to_delete.file_path)
+                    print(f"[파일 삭제] 파일 시스템에서 삭제: {file_to_delete.file_path}")
+                
+                # 관련 Child Chunk (DocumentChunk) 삭제
+                child_chunk_count = DocumentChunk.query.filter_by(file_id=file_to_delete.id).count()
+                if child_chunk_count > 0:
+                    DocumentChunk.query.filter_by(file_id=file_to_delete.id).delete()
+                    print(f"[파일 삭제] Child Chunk {child_chunk_count}개 삭제 완료")
                 
-                # 관련 청크도 삭제
-                DocumentChunk.query.filter_by(file_id=file_to_delete.id).delete()
+                # 관련 Parent Chunk 삭제
+                parent_chunk = ParentChunk.query.filter_by(file_id=file_to_delete.id).first()
+                if parent_chunk:
+                    db.session.delete(parent_chunk)
+                    print(f"[파일 삭제] Parent Chunk 삭제 완료")
                 
                 deleted_files.append(file_to_delete.original_filename)
                 db.session.delete(file_to_delete)
                 deleted_count += 1
+                print(f"[파일 삭제] 데이터베이스에서 파일 삭제 완료: {file_to_delete.original_filename}")
             except Exception as e:
                 print(f"[파일 삭제 오류] {file_to_delete.original_filename}: {str(e)}")
+                import traceback
+                traceback.print_exc()
         
         db.session.commit()
         

download_exaone_model.py

@@ -0,0 +1,72 @@
+"""
+EXAONE-3.0-7.8B-Instruct 모델을 Hugging Face에서 다운로드하고
+Ollama에서 사용할 수 있도록 준비하는 스크립트
+"""
+
+import os
+from huggingface_hub import snapshot_download, login
+
+HF_TOKEN = "YOUR_HUGGINGFACE_TOKEN_HERE"
+MODEL_NAME = "LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct"
+
+def download_model():
+    """Hugging Face에서 모델 다운로드"""
+    print("=" * 60)
+    print("EXAONE-3.0-7.8B-Instruct 모델 다운로드")
+    print("=" * 60)
+    
+    # Hugging Face 로그인
+    try:
+        login(token=HF_TOKEN)
+        print("[OK] Hugging Face 로그인 성공")
+    except Exception as e:
+        print(f"[ERROR] Hugging Face 로그인 실패: {e}")
+        return False
+    
+    # 모델 다운로드
+    try:
+        print(f"\n모델 다운로드 시작: {MODEL_NAME}")
+        print("주의: 모델 크기가 약 15GB이므로 시간이 걸릴 수 있습니다...")
+        
+        download_path = snapshot_download(
+            repo_id=MODEL_NAME,
+            token=HF_TOKEN,
+            local_dir="./models/EXAONE-3.0-7.8B-Instruct",
+            local_dir_use_symlinks=False
+        )
+        
+        print(f"\n[OK] 모델 다운로드 완료!")
+        print(f"저장 위치: {download_path}")
+        return True
+        
+    except Exception as e:
+        print(f"[ERROR] 모델 다운로드 실패: {e}")
+        return False
+
+if __name__ == "__main__":
+    import sys
+    
+    print("\n이 스크립트는 EXAONE 모델을 Hugging Face에서 다운로드합니다.")
+    print("다운로드된 모델은 Ollama에서 직접 사용할 수 없으며,")
+    print("GGUF 형식으로 변환하는 추가 작업이 필요합니다.")
+    print("\n참고: Ollama는 일반적으로 GGUF 형식의 모델만 지원합니다.")
+    
+    response = input("\n계속하시겠습니까? (y/n): ")
+    if response.lower() != 'y':
+        print("다운로드를 취소했습니다.")
+        sys.exit(0)
+    
+    success = download_model()
+    
+    if success:
+        print("\n" + "=" * 60)
+        print("다운로드 완료!")
+        print("=" * 60)
+        print("\n다음 단계:")
+        print("1. llama.cpp를 사용하여 GGUF 형식으로 변환")
+        print("2. 변환된 모델을 Ollama에 추가")
+        print("\n자세한 내용은 EXAONE_설치_가이드.md를 참고하세요.")
+        print("=" * 60)
+    else:
+        print("\n다운로드에 실패했습니다.")
+

install_exaone_direct.py

@@ -0,0 +1,77 @@
+"""
+EXAONE-3.0-7.8B-Instruct를 Ollama에 직접 추가하는 스크립트
+토큰을 사용하여 모델을 추가합니다.
+"""
+
+import os
+import subprocess
+import json
+
+HF_TOKEN = "YOUR_HUGGINGFACE_TOKEN_HERE"
+
+def create_simple_modelfile():
+    """간단한 Modelfile 생성 (로컬 경로 대신 모델 이름만 사용)"""
+    modelfile_content = """# EXAONE-3.0-7.8B-Instruct 모델 설정
+# 참고: Ollama가 Hugging Face 모델을 직접 지원하지 않는 경우
+# 다른 방법이 필요할 수 있습니다.
+
+PARAMETER temperature 0.7
+PARAMETER top_p 0.9
+PARAMETER top_k 40
+PARAMETER num_ctx 4096
+
+SYSTEM \"\"\"You are EXAONE, a helpful AI assistant developed by LG AI Research. 
+You can communicate in both Korean and English.\"\"\"
+"""
+    
+    with open("EXAONE-3.0-7.8B-Instruct.modelfile", "w", encoding="utf-8") as f:
+        f.write(modelfile_content)
+    
+    print("[OK] Modelfile 생성 완료")
+
+def check_model_availability():
+    """모델이 이미 설치되어 있는지 확인"""
+    try:
+        result = subprocess.run(['ollama', 'list'], 
+                              capture_output=True, text=True, timeout=5)
+        if 'EXAONE' in result.stdout or 'exaone' in result.stdout.lower():
+            print("[INFO] EXAONE 모델이 이미 설치되어 있습니다.")
+            return True
+        return False
+    except Exception as e:
+        print(f"[WARNING] 모델 확인 중 오류: {e}")
+        return False
+
+def main():
+    print("\n" + "=" * 60)
+    print("EXAONE-3.0-7.8B-Instruct Ollama 추가 시도")
+    print("=" * 60)
+    
+    # 토큰 설정
+    os.environ['HUGGINGFACE_HUB_TOKEN'] = HF_TOKEN
+    print(f"[OK] Hugging Face 토큰 설정 완료")
+    
+    # 모델 확인
+    if check_model_availability():
+        print("\n모델이 이미 설치되어 있습니다.")
+        return
+    
+    print("\n현재 Ollama 버전에서는 Hugging Face 모델을 직접 가져올 수 없습니다.")
+    print("\n다음 방법을 시도해보세요:")
+    print("\n1. Ollama를 최신 버전으로 업데이트")
+    print("   https://ollama.ai/download")
+    
+    print("\n2. 수동으로 모델 정보 확인")
+    print("   현재 Ollama 버전 확인: ollama --version")
+    print("   사용 가능한 모델 확인: ollama list")
+    
+    print("\n3. EXAONE 모델의 GGUF 버전 찾기")
+    print("   Hugging Face에서 GGUF 형식의 모델을 찾아보세요.")
+    
+    print("\n" + "=" * 60)
+    print("참고: 현재 Ollama 0.13.0은 Hugging Face 모델 직접 지원이 제한적입니다.")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()
+

install_exaone_simple.py

@@ -0,0 +1,54 @@
+"""
+EXAONE-3.0-7.8B-Instruct 모델을 Ollama에 추가하는 간단한 스크립트
+Ollama 0.13.0에서는 직접 Hugging Face 모델을 지원하지 않으므로
+다른 방법을 안내합니다.
+"""
+
+import os
+import subprocess
+from pathlib import Path
+
+HF_TOKEN = "YOUR_HUGGINGFACE_TOKEN_HERE"
+
+def main():
+    print("\n" + "=" * 60)
+    print("EXAONE-3.0-7.8B-Instruct Ollama 추가 가이드")
+    print("=" * 60)
+    
+    print("\n현재 Ollama 버전(0.13.0)에서는 Hugging Face 모델을 직접 가져올 수 없습니다.")
+    print("\n다음 방법 중 하나를 선택하세요:")
+    print("\n[방법 1] Ollama 업데이트 (권장)")
+    print("-" * 60)
+    print("최신 버전의 Ollama는 Hugging Face 모델을 더 잘 지원합니다.")
+    print("https://ollama.ai/download 에서 최신 버전을 다운로드하세요.")
+    
+    print("\n[방법 2] GGUF 모델 사용")
+    print("-" * 60)
+    print("EXAONE 모델의 GGUF 버전이 있다면 직접 다운로드하여 사용할 수 있습니다.")
+    print("하지만 현재 Hugging Face에는 GGUF 버전이 없는 것으로 보입니다.")
+    
+    print("\n[방법 3] Python에서 직접 사용")
+    print("-" * 60)
+    print("Ollama를 통하지 않고 Python에서 직접 Hugging Face 모델을 사용할 수 있습니다.")
+    print("하지만 이 경우 Ollama API와의 통합이 필요합니다.")
+    
+    print("\n[방법 4] Modelfile 수정")
+    print("-" * 60)
+    print("로컬에 모델을 다운로드한 후 Modelfile에서 로컬 경로를 참조할 수 있습니다.")
+    
+    print("\n" + "=" * 60)
+    print("추천: Ollama를 최신 버전으로 업데이트하세요")
+    print("=" * 60)
+    
+    print("\n현재 상태:")
+    print(f"- Hugging Face 토큰: 설정됨")
+    print(f"- Ollama 버전: 0.13.0 (최신 버전 권장)")
+    
+    print("\n다음 명령어로 Ollama 버전을 확인하세요:")
+    print("  ollama --version")
+    
+    print("\nOllama를 업데이트한 후 다시 시도하세요.")
+
+if __name__ == "__main__":
+    main()
+

templates/admin_webnovels.html

@@ -320,6 +320,119 @@
             display: flex;
             gap: 4px;
         }
+
+        /* Parent Chunk 모달 스타일 */
+        .modal {
+            display: none;
+            position: fixed;
+            z-index: 1000;
+            left: 0;
+            top: 0;
+            width: 100%;
+            height: 100%;
+            background-color: rgba(0, 0, 0, 0.5);
+            overflow: auto;
+        }
+
+        .modal.active {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .modal-content {
+            background-color: white;
+            margin: auto;
+            padding: 0;
+            border-radius: 8px;
+            width: 90%;
+            max-width: 900px;
+            max-height: 90vh;
+            display: flex;
+            flex-direction: column;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+
+        .modal-header {
+            padding: 20px 24px;
+            border-bottom: 1px solid #dadce0;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .modal-header h2 {
+            font-size: 20px;
+            font-weight: 600;
+            margin: 0;
+        }
+
+        .modal-close {
+            background: none;
+            border: none;
+            font-size: 24px;
+            cursor: pointer;
+            color: #5f6368;
+            padding: 0;
+            width: 32px;
+            height: 32px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            border-radius: 50%;
+            transition: background 0.2s;
+        }
+
+        .modal-close:hover {
+            background: #f1f3f4;
+        }
+
+        .modal-body {
+            padding: 24px;
+            overflow-y: auto;
+            flex: 1;
+        }
+
+        .parent-chunk-section {
+            margin-bottom: 24px;
+        }
+
+        .parent-chunk-section:last-child {
+            margin-bottom: 0;
+        }
+
+        .parent-chunk-section-title {
+            font-size: 16px;
+            font-weight: 600;
+            color: #1a73e8;
+            margin-bottom: 12px;
+            padding-bottom: 8px;
+            border-bottom: 2px solid #e8f0fe;
+        }
+
+        .parent-chunk-section-content {
+            font-size: 14px;
+            line-height: 1.8;
+            color: #202124;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+            background: #f8f9fa;
+            padding: 16px;
+            border-radius: 6px;
+            border-left: 4px solid #1a73e8;
+        }
+
+        .parent-chunk-empty {
+            text-align: center;
+            padding: 40px;
+            color: #5f6368;
+        }
+
+        .parent-chunk-loading {
+            text-align: center;
+            padding: 40px;
+            color: #1a73e8;
+        }
     </style>
 </head>
 <body>
@@ -429,6 +542,19 @@
         </div>
     </div>
 
+    <!-- Parent Chunk 모달 -->
+    <div id="parentChunkModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2 id="parentChunkModalTitle">Parent Chunk 확인</h2>
+                <button class="modal-close" onclick="closeParentChunkModal()">&times;</button>
+            </div>
+            <div class="modal-body" id="parentChunkModalBody">
+                <div class="parent-chunk-loading">로딩 중...</div>
+            </div>
+        </div>
+    </div>
+
     <script>
         function showAlert(message, type = 'success') {
             const container = document.getElementById('alertContainer');
@@ -521,6 +647,7 @@
                             <td>${uploadDate}</td>
                             <td>
                                 <div class="file-actions">
+                                    <button class="btn btn-primary" onclick="viewParentChunk(${file.id}, '${escapeHtml(file.original_filename)}')" style="padding: 4px 8px; font-size: 12px; margin-right: 4px;">Parent Chunk</button>
                                     <button class="btn btn-primary" onclick="continueUpload(${file.id})" style="padding: 4px 8px; font-size: 12px; margin-right: 4px;">이어서 업로드</button>
                                     <button class="btn btn-secondary" onclick="deleteFile(${file.id})" style="padding: 4px 8px; font-size: 12px;">삭제</button>
                                 </div>
@@ -796,6 +923,108 @@
             }
         });
 
+        // Parent Chunk 확인
+        async function viewParentChunk(fileId, fileName) {
+            const modal = document.getElementById('parentChunkModal');
+            const modalTitle = document.getElementById('parentChunkModalTitle');
+            const modalBody = document.getElementById('parentChunkModalBody');
+            
+            modalTitle.textContent = `Parent Chunk 확인 - ${fileName}`;
+            modalBody.innerHTML = '<div class="parent-chunk-loading">로딩 중...</div>';
+            modal.classList.add('active');
+            
+            try {
+                const response = await fetch(`/api/files/${fileId}/parent-chunk`);
+                const data = await response.json();
+                
+                if (response.ok) {
+                    if (data.has_parent_chunk && data.parent_chunk) {
+                        const chunk = data.parent_chunk;
+                        let html = '';
+                        
+                        if (chunk.world_view) {
+                            html += `
+                                <div class="parent-chunk-section">
+                                    <div class="parent-chunk-section-title">🌍 세계관 설명</div>
+                                    <div class="parent-chunk-section-content">${escapeHtml(chunk.world_view)}</div>
+                                </div>
+                            `;
+                        }
+                        
+                        if (chunk.characters) {
+                            html += `
+                                <div class="parent-chunk-section">
+                                    <div class="parent-chunk-section-title">👥 주요 캐릭터 분석</div>
+                                    <div class="parent-chunk-section-content">${escapeHtml(chunk.characters)}</div>
+                                </div>
+                            `;
+                        }
+                        
+                        if (chunk.story) {
+                            html += `
+                                <div class="parent-chunk-section">
+                                    <div class="parent-chunk-section-title">📖 주요 스토리 분석</div>
+                                    <div class="parent-chunk-section-content">${escapeHtml(chunk.story)}</div>
+                                </div>
+                            `;
+                        }
+                        
+                        if (chunk.episodes) {
+                            html += `
+                                <div class="parent-chunk-section">
+                                    <div class="parent-chunk-section-title">📚 주요 에피소드 분석</div>
+                                    <div class="parent-chunk-section-content">${escapeHtml(chunk.episodes)}</div>
+                                </div>
+                            `;
+                        }
+                        
+                        if (chunk.others) {
+                            html += `
+                                <div class="parent-chunk-section">
+                                    <div class="parent-chunk-section-title">📝 기타</div>
+                                    <div class="parent-chunk-section-content">${escapeHtml(chunk.others)}</div>
+                                </div>
+                            `;
+                        }
+                        
+                        if (!html) {
+                            html = '<div class="parent-chunk-empty">Parent Chunk 내용이 비어있습니다.</div>';
+                        }
+                        
+                        modalBody.innerHTML = html;
+                    } else {
+                        modalBody.innerHTML = '<div class="parent-chunk-empty">Parent Chunk가 생성되지 않았습니다.<br>파일 업로드 시 AI 분석을 통해 자동으로 생성됩니다.</div>';
+                    }
+                } else {
+                    modalBody.innerHTML = `<div class="parent-chunk-empty" style="color: #c5221f;">오류: ${data.error || 'Parent Chunk를 불러올 수 없습니다.'}</div>`;
+                }
+            } catch (error) {
+                modalBody.innerHTML = `<div class="parent-chunk-empty" style="color: #c5221f;">오류: ${error.message}</div>`;
+                console.error('Parent Chunk 조회 오류:', error);
+            }
+        }
+
+        // Parent Chunk 모달 닫기
+        function closeParentChunkModal() {
+            const modal = document.getElementById('parentChunkModal');
+            modal.classList.remove('active');
+        }
+
+        // 모달 외부 클릭 시 닫기
+        window.addEventListener('click', (event) => {
+            const modal = document.getElementById('parentChunkModal');
+            if (event.target === modal) {
+                closeParentChunkModal();
+            }
+        });
+
+        // ESC 키로 모달 닫기
+        document.addEventListener('keydown', (event) => {
+            if (event.key === 'Escape') {
+                closeParentChunkModal();
+            }
+        });
+
         // 페이지 로드 시 초기화
         window.addEventListener('load', () => {
             loadModelsForFiles();