feat: 메타데이터 추가 옵션, Parent Chunk 수동 생성, 각주 표시 기능 추가

- 웹소설 업로드 시 메타데이터 추가 옵션 체크박스 추가
- 관리페이지에서 Parent Chunk 수동 생성 기능 추가
- 관리페이지에서 모든 AI 모델 목록 표시
- AI 답변에 [근거: ] 형식을 각주로 변환하여 표시
- 각주 번호에 마우스 오버 시 툴팁으로 내용 표시
- DocumentChunk 모델에 chunk_metadata 필드 추가
- 청크 생성 시 챕터 번호, 화자, 등장인물, 시간적 배경 메타데이터 추출

EXAONE_설치_가이드.md

@@ -147,3 +147,7 @@ tokenizer = AutoTokenizer.from_pretrained("LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct"
 
 하지만 이 경우 Ollama API와 통합하려면 추가 작업이 필요합니다.
 
+
+
+
+

EXAONE_추가_안내.md

@@ -64,3 +64,7 @@ Ollama를 거치지 않고 Python에서 직접 Hugging Face 모델을 사용할
 - [EXAONE 모델 페이지](https://huggingface.co/LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct)
 - [Ollama 공식 문서](https://github.com/ollama/ollama)
 
+
+
+
+

GIT_SETUP.md

@@ -67,3 +67,7 @@ gh repo create soy-nv-ai --public --source=. --remote=origin --push
 3. README.md 업데이트 (프로젝트 설명 추가)
 
 
+
+
+
+

README_SERVER.md

@@ -67,3 +67,7 @@ Start-Process powershell -ArgumentList "-File", "start_server_background.ps1" -W
 2. 또는 작업 관리자에서 Python 프로세스 종료
 
 
+
+
+
+

add_exaone_model.py

@@ -142,3 +142,7 @@ if __name__ == "__main__":
     print("3. 모델이 목록에 나타나면 웹 애플리케이션에서 사용할 수 있습니다.")
     print("=" * 60 + "\n")
 
+
+
+
+

app/__init__.py

@@ -86,6 +86,19 @@ def migrate_database(app):
                     conn.commit()
                     print("[마이그레이션] uploaded_file.parent_file_id 컬럼 추가 완료")
             
+            # document_chunk 테이블이 존재하는지 확인
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='document_chunk'")
+            if cursor.fetchone():
+                # document_chunk 테이블에 chunk_metadata 컬럼이 있는지 확인
+                cursor.execute("PRAGMA table_info(document_chunk)")
+                document_chunk_columns = [column[1] for column in cursor.fetchall()]
+                
+                if 'chunk_metadata' not in document_chunk_columns:
+                    print("[마이그레이션] document_chunk 테이블에 chunk_metadata 컬럼 추가 중...")
+                    cursor.execute("ALTER TABLE document_chunk ADD COLUMN chunk_metadata TEXT")
+                    conn.commit()
+                    print("[마이그레이션] document_chunk.chunk_metadata 컬럼 추가 완료")
+            
             conn.close()
             print("[마이그레이션] 데이터베이스 마이그레이션 완료")
     except Exception as e:

app/database.py

@@ -113,17 +113,27 @@ class DocumentChunk(db.Model):
     chunk_index = db.Column(db.Integer, nullable=False)  # 청크 순서
     content = db.Column(db.Text, nullable=False)  # 청크 내용
     embedding = db.Column(db.Text, nullable=True)  # 임베딩 벡터 (JSON 문자열로 저장)
+    chunk_metadata = db.Column(db.Text, nullable=True)  # 메타데이터 (JSON 문자열로 저장: chapter, pov, characters, time_background)
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     
     # 관계
     file = db.relationship('UploadedFile', backref='chunks')
     
     def to_dict(self):
+        import json
+        metadata_dict = None
+        if self.chunk_metadata:
+            try:
+                metadata_dict = json.loads(self.chunk_metadata)
+            except:
+                metadata_dict = None
+        
         return {
             'id': self.id,
             'file_id': self.file_id,
             'chunk_index': self.chunk_index,
             'content': self.content,
+            'metadata': metadata_dict,
             'created_at': self.created_at.isoformat() if self.created_at else None
         }
 

app/routes.py

@@ -181,11 +181,196 @@ def split_text_into_chunks(text, min_chunk_size=200, max_chunk_size=1000, overla
     
     return final_chunks if final_chunks else [text] if text.strip() else []
 
-def create_chunks_for_file(file_id, content):
-    """파일 내용을 의미 기반 청크로 분할하여 저장 (벡터 DB 포함)"""
+def extract_chapter_number(text):
+    """텍스트에서 챕터 번호 추출"""
+    # 다양한 챕터 패턴 매칭
+    patterns = [
+        r'제\s*(\d+)\s*장',  # 제1장, 제 1 장
+        r'제\s*(\d+)\s*화',  # 제1화
+        r'Chapter\s*(\d+)',  # Chapter 1
+        r'CHAPTER\s*(\d+)',  # CHAPTER 1
+        r'Ch\.\s*(\d+)',     # Ch. 1
+        r'(\d+)\s*장',       # 1장
+        r'(\d+)\s*화',       # 1화
+        r'CHAPTER\s*(\d+)',  # CHAPTER 1
+        r'chap\.\s*(\d+)',   # chap. 1
+        r'ch\s*(\d+)',       # ch 1
+        r'(\d+)\s*章',       # 1章
+    ]
+    
+    # 텍스트의 처음 500자만 검사 (챕터 정보는 보통 앞부분에 있음)
+    search_text = text[:500]
+    
+    for pattern in patterns:
+        match = re.search(pattern, search_text, re.IGNORECASE)
+        if match:
+            try:
+                chapter_num = int(match.group(1))
+                return chapter_num
+            except:
+                continue
+    
+    return None
+
+def extract_metadata_with_ai(chunk_content, parent_chunk=None, model_name=None):
+    """AI를 사용하여 청크의 메타데이터 추출 (화자, 등장인물, 시간적 배경)"""
+    try:
+        # 간단한 추출을 위해 짧은 프롬프트 사용
+        prompt = f"""다음 웹소설 텍스트를 분석하여 아래 정보를 JSON 형식으로만 응답하세요:
+
+텍스트:
+{chunk_content[:2000]}
+
+다음 형식으로만 응답하세요 (JSON 형식):
+{{
+    "pov": "화자/시점을 설명하세요 (예: 1인칭 주인공, 3인칭 전지적 작가 등)",
+    "characters": ["등장인물1", "등장인물2"],
+    "time_background": "시간적 배경 설명 (예: 과거 회상, 현재 시점, 미래 등)"
+}}
+
+응답은 오직 JSON 형식만 사용하고, 다른 설명은 포함하지 마세요."""
+
+        # 모델명이 없으면 기본값 사용 (Gemini 우선 시도)
+        if not model_name:
+            # Gemini 시도
+            try:
+                gemini_client = get_gemini_client()
+                if gemini_client.is_configured():
+                    result = gemini_client.generate_response(
+                        prompt=prompt,
+                        model_name="gemini-1.5-flash",
+                        temperature=0.3,
+                        max_output_tokens=500
+                    )
+                    if not result['error'] and result.get('response'):
+                        response_text = result['response'].strip()
+                        # JSON 추출
+                        json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+                        if json_match:
+                            metadata = json.loads(json_match.group(0))
+                            return metadata
+            except:
+                pass
+        
+        # 모델명이 있거나 Gemini 실패 시 해당 모델 사용
+        if model_name:
+            model_name_lower = model_name.lower().strip()
+            is_gemini = model_name_lower.startswith('gemini:') or model_name_lower.startswith('gemini-')
+            
+            if is_gemini:
+                gemini_model_name = model_name.strip()
+                if gemini_model_name.lower().startswith('gemini:'):
+                    gemini_model_name = gemini_model_name.split(':', 1)[1].strip()
+                
+                gemini_client = get_gemini_client()
+                if gemini_client.is_configured():
+                    result = gemini_client.generate_response(
+                        prompt=prompt,
+                        model_name=gemini_model_name,
+                        temperature=0.3,
+                        max_output_tokens=500
+                    )
+                    if not result['error'] and result.get('response'):
+                        response_text = result['response'].strip()
+                        json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+                        if json_match:
+                            metadata = json.loads(json_match.group(0))
+                            return metadata
+            else:
+                # Ollama API 호출
+                try:
+                    ollama_response = requests.post(
+                        f'{OLLAMA_BASE_URL}/api/generate',
+                        json={
+                            'model': model_name,
+                            'prompt': prompt,
+                            'stream': False,
+                            'options': {
+                                'temperature': 0.3,
+                                'num_predict': 500
+                            }
+                        },
+                        timeout=30
+                    )
+                    if ollama_response.status_code == 200:
+                        response_data = ollama_response.json()
+                        response_text = response_data.get('response', '').strip()
+                        json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+                        if json_match:
+                            metadata = json.loads(json_match.group(0))
+                            return metadata
+                except:
+                    pass
+        
+        # AI 추출 실패 시 기본값 반환
+        return {
+            "pov": None,
+            "characters": [],
+            "time_background": None
+        }
+    except Exception as e:
+        print(f"[메타데이터 추출] 오류: {str(e)}")
+        return {
+            "pov": None,
+            "characters": [],
+            "time_background": None
+        }
+
+def extract_chunk_metadata(chunk_content, full_content=None, chunk_index=None, file_id=None, model_name=None):
+    """청크의 메타데이터 추출 (챕터, 화자, 등장인물, 시간적 배경)"""
+    metadata = {
+        "chapter": None,
+        "pov": None,
+        "characters": [],
+        "time_background": None
+    }
+    
+    # 1. 챕터 번호 추출 (정규식 기반)
+    chapter_num = extract_chapter_number(chunk_content)
+    if chapter_num:
+        metadata["chapter"] = chapter_num
+    elif full_content and chunk_index is not None:
+        # 청크 앞부분 컨텍스트에서 챕터 찾기
+        context_start = max(0, sum(len(c) for c in chunk_content.split('\n')[:10]))
+        if full_content and len(full_content) > context_start:
+            context = full_content[:context_start + 1000]
+            chapter_num = extract_chapter_number(context)
+            if chapter_num:
+                metadata["chapter"] = chapter_num
+    
+    # 2. AI를 사용한 메타데이터 추출 (화자, 등장인물, 시간적 배경)
+    # Parent Chunk가 있으면 참조
+    parent_chunk = None
+    if file_id:
+        try:
+            parent_chunk = ParentChunk.query.filter_by(file_id=file_id).first()
+        except:
+            pass
+    
+    ai_metadata = extract_metadata_with_ai(chunk_content, parent_chunk, model_name)
+    if ai_metadata:
+        metadata["pov"] = ai_metadata.get("pov")
+        metadata["characters"] = ai_metadata.get("characters", [])
+        metadata["time_background"] = ai_metadata.get("time_background")
+    
+    return metadata
+
+def create_chunks_for_file(file_id, content, extract_metadata=True):
+    """파일 내용을 의미 기반 청크로 분할하여 저장 (벡터 DB 포함 + 메타데이터 태그)
+    
+    Args:
+        file_id: 파일 ID
+        content: 파일 내용
+        extract_metadata: 메타데이터 추출 여부 (기본값: True)
+    """
     try:
         print(f"[청크 생성] 파일 ID {file_id}에 대한 청크 생성 시작")
         print(f"[청크 생성] 원본 텍스트 길이: {len(content)}자")
+        print(f"[청크 생성] 메타데이터 추출: {'예' if extract_metadata else '아니오'}")
+        
+        # 파일 정보 가져오기 (모델명 등)
+        uploaded_file = UploadedFile.query.get(file_id)
+        model_name = uploaded_file.model_name if uploaded_file else None
         
         # 벡터 DB 매니저 가져오기
         vector_db = get_vector_db()
@@ -212,13 +397,40 @@ def create_chunks_for_file(file_id, content):
         # 각 청크를 데이터베이스와 벡터 DB에 저장
         saved_count = 0
         vector_saved_count = 0
+        metadata_extracted_count = 0
+        
+        if extract_metadata:
+            print(f"[청크 생성] 메타데이터 추출 시작 (AI 사용: {model_name is not None})...")
+        else:
+            print(f"[청크 생성] 메타데이터 추출 건너뜀 (사용자 선택)")
+        
         for idx, chunk_content in enumerate(chunks):
             try:
-                # DB에 청크 저장
+                # 메타데이터 추출 (옵션이 활성화된 경우에만)
+                metadata = None
+                metadata_json = None
+                
+                if extract_metadata:
+                    metadata = extract_chunk_metadata(
+                        chunk_content=chunk_content,
+                        full_content=content,
+                        chunk_index=idx,
+                        file_id=file_id,
+                        model_name=model_name
+                    )
+                    
+                    # 메타데이터를 JSON 문자열로 변환
+                    metadata_json = json.dumps(metadata, ensure_ascii=False) if metadata else None
+                    
+                    if metadata and (metadata.get("chapter") or metadata.get("pov") or metadata.get("characters") or metadata.get("time_background")):
+                        metadata_extracted_count += 1
+                
+                # DB에 청크 저장 (메타데이터 포함)
                 chunk = DocumentChunk(
                     file_id=file_id,
                     chunk_index=idx,
-                    content=chunk_content
+                    content=chunk_content,
+                    chunk_metadata=metadata_json
                 )
                 db.session.add(chunk)
                 db.session.flush()  # ID 생성
@@ -236,13 +448,15 @@ def create_chunks_for_file(file_id, content):
                 
                 # 진행 상황 출력 (10개마다)
                 if (idx + 1) % 10 == 0:
-                    print(f"[청크 생성] 진행 중: {idx + 1}/{len(chunks)}개 청크 저장 중... (DB: {saved_count}, 벡터 DB: {vector_saved_count})")
+                    print(f"[청크 생성] 진행 중: {idx + 1}/{len(chunks)}개 청크 저장 중... (DB: {saved_count}, 벡터 DB: {vector_saved_count}, 메타데이터: {metadata_extracted_count})")
             except Exception as e:
                 print(f"[청크 생성] 경고: 청크 {idx} 저장 중 오류: {str(e)}")
+                import traceback
+                traceback.print_exc()
                 continue
         
         db.session.commit()
-        print(f"[청크 생성] 완료: {saved_count}개 청크가 데이터베이스에 저장되었습니다. (벡터 DB: {vector_saved_count}개)")
+        print(f"[청크 생성] 완료: {saved_count}개 청크가 데이터베이스에 저장되었습니다. (벡터 DB: {vector_saved_count}개, 메타데이터 추출: {metadata_extracted_count}개)")
         
         # 저장 확인
         verified_count = DocumentChunk.query.filter_by(file_id=file_id).count()
@@ -986,29 +1200,61 @@ def set_gemini_api_key():
 @main_bp.route('/api/ollama/models', methods=['GET'])
 @login_required
 def get_ollama_models():
-    """Ollama 및 Gemini에서 사용 가능한 모델 목록 가져오기"""
+    """Ollama 및 Gemini에서 사용 가능한 모델 목록 가져오기 (로컬 AI 모델은 학습된 웹소설이 있는 모델만 표시)"""
     try:
         all_models = []
         
-        # 1. Ollama 모델 목록 가져오기
+        # 1. Ollama 모델 목록 가져오기 (학습된 웹소설이 있는 모델만 필터링)
         try:
             response = requests.get(f'{OLLAMA_BASE_URL}/api/tags', timeout=5)
             if response.status_code == 200:
                 data = response.json()
-                ollama_models = [{'name': model['name'], 'type': 'ollama'} for model in data.get('models', [])]
-                all_models.extend(ollama_models)
-                print(f"[모델 목록] Ollama 모델 {len(ollama_models)}개 추가")
+                ollama_models_raw = [model['name'] for model in data.get('models', [])]
+                
+                # 각 Ollama 모델에 대해 학습된 웹소설이 있는지 확인
+                filtered_ollama_models = []
+                for model_name in ollama_models_raw:
+                    # 해당 모델로 학습된 원본 파일이 있는지 확인 (parent_file_id가 None인 파일만)
+                    file_count = UploadedFile.query.filter_by(
+                        model_name=model_name,
+                        parent_file_id=None
+                    ).count()
+                    
+                    if file_count > 0:
+                        filtered_ollama_models.append({'name': model_name, 'type': 'ollama'})
+                        print(f"[모델 목록] Ollama 모델 '{model_name}' - 학습된 웹소설 {file_count}개")
+                    else:
+                        print(f"[모델 목록] Ollama 모델 '{model_name}' - 학습된 웹소설 없음, 목록에서 제외")
+                
+                all_models.extend(filtered_ollama_models)
+                print(f"[모델 목록] Ollama 모델 {len(filtered_ollama_models)}개 추가 (전체 {len(ollama_models_raw)}개 중 {len(filtered_ollama_models)}개 필터링됨)")
         except Exception as e:
             print(f"[모델 목록] Ollama 모델 목록 조회 실패: {e}")
         
-        # 2. Gemini 모델 목록 가져오기
+        # 2. Gemini 모델 목록 가져오기 (학습된 웹소설이 있는 모델만 필터링)
         try:
             gemini_client = get_gemini_client()
             if gemini_client.is_configured():
                 gemini_models = gemini_client.get_available_models()
-                gemini_model_list = [{'name': f'gemini:{model_name}', 'type': 'gemini'} for model_name in gemini_models]
-                all_models.extend(gemini_model_list)
-                print(f"[모델 목록] Gemini 모델 {len(gemini_model_list)}개 추가")
+                
+                # 각 Gemini 모델에 대해 학습된 웹소설이 있는지 확인
+                filtered_gemini_models = []
+                for model_name in gemini_models:
+                    full_model_name = f'gemini:{model_name}'
+                    # 해당 모델로 학습된 원본 파일이 있는지 확인 (parent_file_id가 None인 파일만)
+                    file_count = UploadedFile.query.filter_by(
+                        model_name=full_model_name,
+                        parent_file_id=None
+                    ).count()
+                    
+                    if file_count > 0:
+                        filtered_gemini_models.append({'name': full_model_name, 'type': 'gemini'})
+                        print(f"[모델 목록] Gemini 모델 '{full_model_name}' - 학습된 웹소설 {file_count}개")
+                    else:
+                        print(f"[모델 목록] Gemini 모델 '{full_model_name}' - 학습된 웹소설 없음, 목록에서 제외")
+                
+                all_models.extend(filtered_gemini_models)
+                print(f"[모델 목록] Gemini 모델 {len(filtered_gemini_models)}개 추가 (전체 {len(gemini_models)}개 중 {len(filtered_gemini_models)}개 필터링됨)")
             else:
                 print(f"[모델 목록] Gemini API 키가 설정되지 않아 Gemini 모델을 불러올 수 없습니다.")
         except Exception as e:
@@ -1022,6 +1268,75 @@ def get_ollama_models():
     except Exception as e:
         return jsonify({'error': f'모델 목록을 가져오는 중 오류가 발생했습니다: {str(e)}', 'models': []}), 500
 
+@main_bp.route('/api/admin/ollama/models', methods=['GET'])
+@admin_required
+def get_all_ollama_models():
+    """관리자용: Ollama 및 Gemini에서 사용 가능한 모든 모델 목록 가져오기 (필터링 없이 전체 목록)"""
+    try:
+        all_models = []
+        
+        # 1. Ollama 모델 목록 가져오기 (필터링 없이 전체 목록)
+        try:
+            response = requests.get(f'{OLLAMA_BASE_URL}/api/tags', timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                ollama_models_raw = [model['name'] for model in data.get('models', [])]
+                
+                # 필터링 없이 모든 Ollama 모델 추가
+                for model_name in ollama_models_raw:
+                    # 각 모델의 학습된 웹소설 개수 확인 (정보 제공용)
+                    file_count = UploadedFile.query.filter_by(
+                        model_name=model_name,
+                        parent_file_id=None
+                    ).count()
+                    
+                    all_models.append({
+                        'name': model_name,
+                        'type': 'ollama',
+                        'file_count': file_count  # 정보 제공용
+                    })
+                    print(f"[관리자 모델 목록] Ollama 모델 '{model_name}' - 학습된 웹소설 {file_count}개")
+                
+                print(f"[관리자 모델 목록] Ollama 모델 {len(ollama_models_raw)}개 추가")
+        except Exception as e:
+            print(f"[관리자 모델 목록] Ollama 모델 목록 조회 실패: {e}")
+        
+        # 2. Gemini 모델 목록 가져오기 (필터링 없이 전체 목록)
+        try:
+            gemini_client = get_gemini_client()
+            if gemini_client.is_configured():
+                gemini_models = gemini_client.get_available_models()
+                
+                # 필터링 없이 모든 Gemini 모델 추가
+                for model_name in gemini_models:
+                    full_model_name = f'gemini:{model_name}'
+                    # 각 모델의 학습된 웹소설 개수 확인 (정보 제공용)
+                    file_count = UploadedFile.query.filter_by(
+                        model_name=full_model_name,
+                        parent_file_id=None
+                    ).count()
+                    
+                    all_models.append({
+                        'name': full_model_name,
+                        'type': 'gemini',
+                        'file_count': file_count  # 정보 제공용
+                    })
+                    print(f"[관리자 모델 목록] Gemini 모델 '{full_model_name}' - 학습된 웹소설 {file_count}개")
+                
+                print(f"[관리자 모델 목록] Gemini 모델 {len(gemini_models)}개 추가")
+            else:
+                print(f"[관리자 모델 목록] Gemini API 키가 설정되지 않아 Gemini 모델을 불러올 수 없습니다.")
+        except Exception as e:
+            print(f"[관리자 모델 목록] Gemini 모델 목록 조회 실패: {e}")
+        
+        if all_models:
+            return jsonify({'models': all_models})
+        else:
+            return jsonify({'error': '사용 가능한 모델이 없습니다. Ollama가 실행 중인지, 또는 Gemini API 키가 설정되었는지 확인하세요.', 'models': []}), 500
+            
+    except Exception as e:
+        return jsonify({'error': f'모델 목록을 가져오는 중 오류가 발생했습니다: {str(e)}', 'models': []}), 500
+
 @main_bp.route('/api/chat', methods=['POST'])
 @login_required
 def chat():
@@ -1435,10 +1750,12 @@ def upload_file():
         file = request.files['file']
         model_name = request.form.get('model_name', '').strip()
         parent_file_id = request.form.get('parent_file_id', None)  # 이어서 업로드할 경우 원본 파일 ID
+        extract_metadata = request.form.get('extract_metadata', 'true').lower() == 'true'  # 메타데이터 추출 여부 (기본값: true)
         
         log_print(f"[2/8] 파일 수신: {file.filename if file else 'None'}")
         log_print(f"[2/8] 모델명: {model_name if model_name else 'None (비어있음)'}")
         log_print(f"[2/8] 이어서 업로드: {parent_file_id if parent_file_id else '아니오'}")
+        log_print(f"[2/8] 메타데이터 추출: {'예' if extract_metadata else '아니오'}")
         
         if file.filename == '':
             error_msg = '파일명이 없습니다.'
@@ -1600,8 +1917,8 @@ def upload_file():
                         log_print(f"[7/8] CP949 인코딩으로 파일 읽기 성공: {len(content)}자")
                     
                     # 청크 생성 및 저장
-                    log_print(f"[7/8] 청크 생성 함수 호출 중...")
-                    chunk_count = create_chunks_for_file(uploaded_file.id, content)
+                    log_print(f"[7/8] 청크 생성 함수 호출 중... (메타데이터 추출: {'예' if extract_metadata else '아니오'})")
+                    chunk_count = create_chunks_for_file(uploaded_file.id, content, extract_metadata=extract_metadata)
                     
                     if chunk_count > 0:
                         log_print(f"[7/8] ✅ 성공: 파일 {original_filename}을 {chunk_count}개의 청크로 분할했습니다.")
@@ -1707,6 +2024,10 @@ def get_files():
             chunk_count = DocumentChunk.query.filter_by(file_id=file.id).count()
             file_dict['chunk_count'] = chunk_count
             
+            # Parent Chunk 존재 여부 확인
+            has_parent_chunk = ParentChunk.query.filter_by(file_id=file.id).first() is not None
+            file_dict['has_parent_chunk'] = has_parent_chunk
+            
             # 이어서 업로드된 파일들도 조회
             child_files = UploadedFile.query.filter_by(parent_file_id=file.id).order_by(UploadedFile.uploaded_at.asc()).all()
             child_files_dict = []
@@ -1714,6 +2035,9 @@ def get_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 파일도 Parent Chunk 확인
+                child_has_parent_chunk = ParentChunk.query.filter_by(file_id=child.id).first() is not None
+                child_dict['has_parent_chunk'] = child_has_parent_chunk
                 child_files_dict.append(child_dict)
             file_dict['child_files'] = child_files_dict
             files_with_children.append(file_dict)
@@ -1811,6 +2135,63 @@ def get_file_parent_chunk(file_id):
     except Exception as e:
         return jsonify({'error': f'Parent Chunk 조회 중 오류가 발생했습니다: {str(e)}'}), 500
 
+@main_bp.route('/api/files/<int:file_id>/parent-chunk', methods=['POST'])
+@login_required
+def create_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
+        
+        # 모델명 확인
+        if not file.model_name:
+            return jsonify({'error': '파일에 연결된 AI 모델이 없습니다. Parent Chunk를 생성할 수 없습니다.'}), 400
+        
+        # 파일이 텍스트 파일인지 확인
+        if not file.original_filename.lower().endswith(('.txt', '.md')):
+            return jsonify({'error': 'Parent Chunk는 텍스트 파일(.txt, .md)에만 생성할 수 있습니다.'}), 400
+        
+        # 파일 내용 읽기
+        try:
+            encoding = 'utf-8'
+            try:
+                with open(file.file_path, 'r', encoding=encoding) as f:
+                    content = f.read()
+            except UnicodeDecodeError:
+                with open(file.file_path, 'r', encoding='cp949') as f:
+                    content = f.read()
+        except Exception as e:
+            return jsonify({'error': f'파일을 읽을 수 없습니다: {str(e)}'}), 500
+        
+        if not content or len(content.strip()) == 0:
+            return jsonify({'error': '파일 내용이 비어있습니다.'}), 400
+        
+        # Parent Chunk 생성
+        print(f"[Parent Chunk 수동 생성] 파일 ID {file_id}에 대한 Parent Chunk 생성 시작")
+        print(f"[Parent Chunk 수동 생성] 모델명: {file.model_name}")
+        print(f"[Parent Chunk 수동 생성] 파일명: {file.original_filename}")
+        
+        parent_chunk = create_parent_chunk_with_ai(file_id, content, file.model_name)
+        
+        if parent_chunk:
+            return jsonify({
+                'file_id': file_id,
+                'filename': file.original_filename,
+                'has_parent_chunk': True,
+                'parent_chunk': parent_chunk.to_dict(),
+                'message': 'Parent Chunk가 ��공적으로 생성되었습니다.'
+            }), 200
+        else:
+            return jsonify({
+                'error': 'Parent Chunk 생성에 실패했습니다. 서버 로그를 확인하세요.',
+                'file_id': file_id,
+                'filename': file.original_filename
+            }), 500
+        
+    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):

download_exaone_model.py

@@ -70,3 +70,7 @@ if __name__ == "__main__":
     else:
         print("\n다운로드에 실패했습니다.")
 
+
+
+
+

install_exaone_direct.py

@@ -75,3 +75,7 @@ def main():
 if __name__ == "__main__":
     main()
 
+
+
+
+

install_exaone_simple.py

@@ -52,3 +52,7 @@ def main():
 if __name__ == "__main__":
     main()
 
+
+
+
+

setup_remote.ps1

@@ -60,3 +60,7 @@ Write-Host ""
 Write-Host "=== 완료 ===" -ForegroundColor Green
 
 
+
+
+
+

templates/admin_webnovels.html

@@ -471,6 +471,18 @@
                 </select>
             </div>
 
+            <!-- 메타데이터 추가 옵션 -->
+            <div style="margin-bottom: 16px; padding: 12px; background: #f8f9fa; border-radius: 6px; border: 1px solid #dadce0;">
+                <label style="display: flex; align-items: center; cursor: pointer; font-size: 14px;">
+                    <input type="checkbox" id="extractMetadataCheckbox" checked style="margin-right: 8px; width: 18px; height: 18px; cursor: pointer;">
+                    <span style="font-weight: 500;">청크에 메타데이터 추가</span>
+                </label>
+                <div style="margin-top: 8px; margin-left: 26px; font-size: 12px; color: #5f6368; line-height: 1.5;">
+                    체크 시 각 청크에 챕터 번호, 화자(POV), 등장인물, 시간적 배경 정보가 자동으로 추출되어 추가됩니다.<br>
+                    <span style="color: #c5221f;">⚠️ 메타데이터 추출은 AI를 사용하므로 시간이 오래 걸릴 수 있습니다.</span>
+                </div>
+            </div>
+
             <!-- 파일 업로드 -->
             <div class="file-upload-input-wrapper" id="fileUploadWrapper">
                 <input type="file" id="fileInput" accept=".txt,.md,.pdf,.docx,.epub" multiple>
@@ -571,10 +583,10 @@
         const fileModelSelect = document.getElementById('fileModelSelect');
         const filesTableBody = document.getElementById('filesTableBody');
 
-        // 모델 목록 로드
+        // 모델 목록 로드 (관리자용: 모든 모델 표시)
         async function loadModelsForFiles() {
             try {
-                const response = await fetch('/api/ollama/models');
+                const response = await fetch('/api/admin/ollama/models');
                 const data = await response.json();
                 
                 fileModelSelect.innerHTML = '<option value="">모델을 선택하세요...</option>';
@@ -583,12 +595,21 @@
                     data.models.forEach(model => {
                         const option = document.createElement('option');
                         option.value = model.name;
-                        option.textContent = model.name;
+                        // 학습된 웹소설 개수가 있으면 표시
+                        const fileCount = model.file_count || 0;
+                        const displayText = fileCount > 0 
+                            ? `${model.name} (${fileCount}개 학습됨)`
+                            : model.name;
+                        option.textContent = displayText;
                         fileModelSelect.appendChild(option);
                     });
+                } else if (data.error) {
+                    console.error('모델 로드 오류:', data.error);
+                    fileModelSelect.innerHTML = '<option value="">모델을 불러올 수 없습니다</option>';
                 }
             } catch (error) {
                 console.error('모델 로드 오류:', error);
+                fileModelSelect.innerHTML = '<option value="">모델 로드 실패</option>';
             }
         }
 
@@ -647,7 +668,10 @@
                             <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>
+                                    ${(file.has_parent_chunk !== undefined && file.has_parent_chunk) ? 
+                                        `<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-secondary" onclick="createParentChunk(${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>
@@ -752,6 +776,9 @@
                 const formData = new FormData();
                 formData.append('file', file);
                 formData.append('model_name', modelName);
+                // 메타데이터 추출 옵션 추가
+                const extractMetadata = document.getElementById('extractMetadataCheckbox').checked;
+                formData.append('extract_metadata', extractMetadata ? 'true' : 'false');
                 
                 // 이어서 업로드인 경우 parent_file_id 추가
                 if (continueUploadFileId) {
@@ -1004,6 +1031,97 @@
             }
         }
 
+        // Parent Chunk 수동 생성
+        async function createParentChunk(fileId, fileName) {
+            if (!confirm(`"${fileName}" 파일에 대해 Parent Chunk를 생성하시겠습니까?\n\n이 작업은 몇 분이 걸릴 수 있으며, AI 모델을 사용합니다.`)) {
+                return;
+            }
+            
+            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">Parent Chunk를 생성하고 있습니다. 이 작업은 몇 분이 걸릴 수 있습니다. 잠시만 기다려주세요...</div>';
+            modal.classList.add('active');
+            
+            try {
+                const response = await fetch(`/api/files/${fileId}/parent-chunk`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                });
+                const data = await response.json();
+                
+                if (response.ok) {
+                    if (data.has_parent_chunk && data.parent_chunk) {
+                        // 생성 성공 - Parent Chunk 내용 표시
+                        const chunk = data.parent_chunk;
+                        let html = '<div style="color: #137333; margin-bottom: 16px; padding: 12px; background: #e8f5e9; border-radius: 6px;">✅ Parent Chunk가 성공적으로 생성되었습니다.</div>';
+                        
+                        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>
+                            `;
+                        }
+                        
+                        modalTitle.textContent = `Parent Chunk 확인 - ${fileName}`;
+                        modalBody.innerHTML = html;
+                        
+                        // 파일 목록 새로고침
+                        await loadFiles();
+                    } else {
+                        modalBody.innerHTML = '<div class="parent-chunk-empty" style="color: #c5221f;">Parent Chunk 생성에 실패했습니다. 서버 로그를 확인하세요.</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');

templates/index.html

@@ -553,8 +553,14 @@
             white-space: pre-wrap;
         }
         
-        .message-bubble strong {
-            font-weight: 700;
+        .message.ai .message-bubble {
+            white-space: normal;
+        }
+        
+        .message.ai .message-bubble br {
+            display: block;
+            content: "";
+            margin: 0;
         }
 
         .message.user .message-bubble {
@@ -568,6 +574,93 @@
             color: var(--text-primary);
             border-bottom-left-radius: 4px;
         }
+        
+        /* 각주 스타일 */
+        .footnote-ref {
+            font-size: 0.75em;
+            vertical-align: super;
+            color: var(--accent);
+            cursor: help;
+            text-decoration: underline;
+            text-decoration-style: dotted;
+            position: relative;
+            font-weight: 500;
+            display: inline-block;
+        }
+        
+        .footnote-ref:hover {
+            color: var(--accent-hover);
+        }
+        
+        /* 각주 툴팁 */
+        .footnote-tooltip {
+            position: absolute;
+            bottom: calc(100% + 8px);
+            left: 50%;
+            transform: translateX(-50%);
+            background: rgba(0, 0, 0, 0.95);
+            color: white;
+            padding: 8px 12px;
+            border-radius: 8px;
+            font-size: 0.75em;
+            max-width: 350px;
+            min-width: 200px;
+            word-wrap: break-word;
+            white-space: normal;
+            opacity: 0;
+            pointer-events: none;
+            transition: opacity 0.2s ease-in-out;
+            z-index: 10000;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4);
+            line-height: 1.4;
+            text-align: left;
+        }
+        
+        .footnote-tooltip::after {
+            content: '';
+            position: absolute;
+            top: 100%;
+            left: 50%;
+            transform: translateX(-50%);
+            border: 6px solid transparent;
+            border-top-color: rgba(0, 0, 0, 0.95);
+        }
+        
+        .footnote-ref:hover .footnote-tooltip {
+            opacity: 1;
+        }
+        
+        /* 각주 번호가 화면 위쪽에 있으면 툴팁을 아래쪽에 표시 */
+        .message-bubble {
+            position: relative;
+        }
+        
+        /* 각주 목록 컨테이너 */
+        .footnotes-container {
+            margin-top: 12px;
+            padding-top: 12px;
+            border-top: 1px solid var(--border);
+            font-size: 0.85em;
+            color: var(--text-secondary);
+        }
+        
+        .footnote-item {
+            margin-bottom: 6px;
+            line-height: 1.4;
+            display: flex;
+            align-items: flex-start;
+            gap: 6px;
+        }
+        
+        .footnote-item sup {
+            font-size: 0.9em;
+            color: var(--accent);
+            font-weight: 500;
+        }
+        
+        .footnote-item span {
+            flex: 1;
+        }
 
         .message-time {
             font-size: 12px;
@@ -1219,26 +1312,36 @@
             }
         });
 
-        // Markdown 스타일 강조 표시를 HTML로 변환
-        function formatMessageText(text) {
-            if (!text) return '';
+        // [근거: ] 형식을 각주로 변환하는 함수
+        function formatContentWithFootnotes(content) {
+            if (!content) return { formattedContent: '', footnotes: [] };
             
-            // HTML 특수문자 이스케이프
-            let html = text
-                .replace(/&/g, '&')
-                .replace(/</g, '&lt;')
-                .replace(/>/g, '&gt;');
+            // 일반 텍스트를 HTML로 변환 (줄바꿈 처리)
+            let htmlContent = escapeHtml(content).replace(/\n/g, '<br>');
             
-            // **텍스트** 패턴을 <strong>텍스트</strong>로 변환
-            // 단, ** 사이에 내용이 있어야 함
-            html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+            // [근거: 내용] 패턴 찾기
+            const footnotePattern = /\[근거:\s*([^\]]+)\]/g;
+            const footnotes = [];
+            let footnoteIndex = 0;
             
-            // 줄바꿈 처리
-            html = html.replace(/\n/g, '<br>');
+            // 각 [근거: ] 부분을 찾아서 각주 번호로 치환
+            let formattedContent = htmlContent.replace(footnotePattern, (match, footnoteText) => {
+                footnoteIndex++;
+                const cleanText = footnoteText.trim();
+                footnotes.push(cleanText);
+                return `<sup class="footnote-ref" data-footnote="${footnoteIndex}">[${footnoteIndex}]<span class="footnote-tooltip">${escapeHtml(cleanText)}</span></sup>`;
+            });
             
-            return html;
+            return { formattedContent, footnotes };
         }
         
+        // HTML 이스케이프 헬퍼
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+
         // 메시지 추가
         function addMessage(role, content, save = true) {
             // 빈 상태 숨기기
@@ -1258,7 +1361,28 @@
 
             const bubble = document.createElement('div');
             bubble.className = 'message-bubble';
-            bubble.innerHTML = formatMessageText(content);
+            
+            // AI 응답인 경우 [근거: ] 형식을 각주로 변환
+            if (role === 'ai') {
+                const { formattedContent, footnotes } = formatContentWithFootnotes(content);
+                bubble.innerHTML = formattedContent;
+                
+                // 각주가 있으면 각주 목록 추가
+                if (footnotes.length > 0) {
+                    const footnoteContainer = document.createElement('div');
+                    footnoteContainer.className = 'footnotes-container';
+                    footnotes.forEach((note, index) => {
+                        const footnoteDiv = document.createElement('div');
+                        footnoteDiv.className = 'footnote-item';
+                        footnoteDiv.innerHTML = `<sup>[${index + 1}]</sup> <span>${escapeHtml(note)}</span>`;
+                        footnoteContainer.appendChild(footnoteDiv);
+                    });
+                    bubble.appendChild(footnoteContainer);
+                }
+            } else {
+                // 사용자 메시지는 일반 텍스트
+                bubble.textContent = content;
+            }
 
             const time = document.createElement('div');
             time.className = 'message-time';

templates/login.html

@@ -160,3 +160,7 @@
 </html>
 
 
+
+
+
+