feat: GraphRAG 기능 추가 및 그래프 시각화 구현

- GraphRAG 데이터 모델 추가 (GraphEntity, GraphRelationship, GraphEvent)
- 회차별 Graph Extraction 기능 구현
- GraphRAG 데이터 조회 API 엔드포인트 추가
- AI 채팅에서 GraphRAG 데이터 참조 기능 추가
- 관리자 페이지 및 웹소설 페이지에 GraphRAG 보기 기능 추가
- GraphRAG 그래프 시각화 기능 추가 (vis-network 사용)
- 에피소드(사건) 시각화 기능 추가
- AI 답변에 마크다운 렌더링 적용

app/database.py

@@ -246,4 +246,97 @@ class EpisodeAnalysis(db.Model):
             'updated_at': self.updated_at.isoformat() if self.updated_at else None
         }
 
+# Graph Extraction 모델 (GraphRAG용)
+class GraphEntity(db.Model):
+    """Graph Extraction에서 추출된 엔티티 (인물/장소)"""
+    id = db.Column(db.Integer, primary_key=True)
+    file_id = db.Column(db.Integer, db.ForeignKey('uploaded_file.id'), nullable=False)
+    episode_title = db.Column(db.String(100), nullable=False)  # 회차 제목
+    entity_name = db.Column(db.String(200), nullable=False)  # 엔티티 이름
+    entity_type = db.Column(db.String(50), nullable=False)  # 'character' 또는 'location'
+    description = db.Column(db.Text, nullable=True)  # 엔티티 설명
+    role = db.Column(db.String(200), nullable=True)  # 인물의 경우 역할
+    category = db.Column(db.String(200), nullable=True)  # 장소의 경우 유형
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    
+    # 관계
+    file = db.relationship('UploadedFile', backref='graph_entities')
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'file_id': self.file_id,
+            'episode_title': self.episode_title,
+            'entity_name': self.entity_name,
+            'entity_type': self.entity_type,
+            'description': self.description,
+            'role': self.role,
+            'category': self.category,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }
+
+class GraphRelationship(db.Model):
+    """Graph Extraction에서 추출된 관계"""
+    id = db.Column(db.Integer, primary_key=True)
+    file_id = db.Column(db.Integer, db.ForeignKey('uploaded_file.id'), nullable=False)
+    episode_title = db.Column(db.String(100), nullable=False)  # 회차 제목
+    source = db.Column(db.String(200), nullable=False)  # 관계의 주체
+    target = db.Column(db.String(200), nullable=False)  # 관계의 대상
+    relationship_type = db.Column(db.String(200), nullable=False)  # 관계 유형
+    description = db.Column(db.Text, nullable=True)  # 관계 설명
+    event = db.Column(db.String(500), nullable=True)  # 관계를 형성/변화시킨 사건
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    
+    # 관계
+    file = db.relationship('UploadedFile', backref='graph_relationships')
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'file_id': self.file_id,
+            'episode_title': self.episode_title,
+            'source': self.source,
+            'target': self.target,
+            'relationship_type': self.relationship_type,
+            'description': self.description,
+            'event': self.event,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }
+
+class GraphEvent(db.Model):
+    """Graph Extraction에서 추출된 사건"""
+    id = db.Column(db.Integer, primary_key=True)
+    file_id = db.Column(db.Integer, db.ForeignKey('uploaded_file.id'), nullable=False)
+    episode_title = db.Column(db.String(100), nullable=False)  # 회차 제목
+    event_name = db.Column(db.String(500), nullable=False)  # 사건 이름
+    description = db.Column(db.Text, nullable=False)  # 사건 설명
+    participants = db.Column(db.Text, nullable=True)  # 관련 인물들 (JSON 문자열로 저장)
+    location = db.Column(db.String(500), nullable=True)  # 사건 발생 장소
+    significance = db.Column(db.String(200), nullable=True)  # 사건의 중요도
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    
+    # 관계
+    file = db.relationship('UploadedFile', backref='graph_events')
+    
+    def to_dict(self):
+        import json
+        participants_list = []
+        if self.participants:
+            try:
+                participants_list = json.loads(self.participants)
+            except:
+                participants_list = []
+        
+        return {
+            'id': self.id,
+            'file_id': self.file_id,
+            'episode_title': self.episode_title,
+            'event_name': self.event_name,
+            'description': self.description,
+            'participants': participants_list,
+            'location': self.location,
+            'significance': self.significance,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }
+
 

app/prompts/__init__.py

@@ -5,10 +5,12 @@ LLM 프롬프트 템플릿을 관리합니다.
 
 from app.prompts.metadata import get_metadata_extraction_prompt
 from app.prompts.parent_chunk import get_parent_chunk_analysis_prompt
+from app.prompts.graph_extraction import get_graph_extraction_prompt
 
 __all__ = [
     'get_metadata_extraction_prompt',
     'get_parent_chunk_analysis_prompt',
+    'get_graph_extraction_prompt',
 ]
 
 

app/prompts/graph_extraction.py

@@ -0,0 +1,105 @@
+"""
+Graph Extraction 프롬프트
+엔티티(인물/장소)와 관계(사건)를 추출하는 GraphRAG 기반 프롬프트
+"""
+
+from typing import Optional
+
+
+def get_graph_extraction_prompt(
+    episode_content: str,
+    episode_title: str,
+    full_content: Optional[str] = None,
+    parent_chunk_info: Optional[str] = None,
+    max_length: int = 10000
+) -> str:
+    """
+    Graph Extraction을 위한 프롬프트 생성
+    
+    Args:
+        episode_content: 분석할 회차 내용
+        episode_title: 회차 제목 (예: '1화', '2화')
+        full_content: 원본 웹소설 전체 내용 (참고용)
+        parent_chunk_info: Parent Chunk 정보 (선택사항)
+        max_length: 프롬프트에 포함할 최대 텍스트 길이
+    
+    Returns:
+        프롬프트 문자열
+    """
+    # 회차 내용 길이 제한
+    content_preview = episode_content[:max_length]
+    is_truncated = len(episode_content) > max_length
+    
+    truncation_note = "\n(참고: 회차 내용이 길어 일부만 사용되었습니다.)" if is_truncated else ""
+    
+    # 전체 내용 참고용 (선택사항)
+    full_content_preview = ""
+    if full_content:
+        # 전체 내용이 너무 길면 앞부분과 뒷부분 일부만 사용
+        if len(full_content) > 30000:
+            full_content_preview = full_content[:15000] + "\n... (중간 생략) ...\n" + full_content[-15000:]
+        else:
+            full_content_preview = full_content
+    
+    prompt = f"""다음 웹소설의 {episode_title} 회차에서 엔티티(인물/장소)와 관계(사건)를 추출해주세요.
+
+{parent_chunk_info if parent_chunk_info else ""}
+
+원본 웹소설 전체 내용 (참고용):
+{full_content_preview[:50000] if full_content_preview else "없음"}
+
+분석할 회차 내용 ({episode_title}):
+{content_preview}{truncation_note}
+
+다음 형식으로 JSON 형식으로만 응답하세요:
+
+{{
+    "entities": {{
+        "characters": [
+            {{
+                "name": "인물 이름",
+                "type": "인물",
+                "description": "인물에 대한 간단한 설명",
+                "role": "이 회차에서의 역할 (예: 주인공, 조연, 악역 등)"
+            }}
+        ],
+        "locations": [
+            {{
+                "name": "장소 이름",
+                "type": "장소",
+                "description": "장소에 대한 간단한 설명",
+                "category": "장소 유형 (예: 도시, 건물, 차원 등)"
+            }}
+        ]
+    }},
+    "relationships": [
+        {{
+            "source": "관계의 주체 (인물 이름)",
+            "target": "관계의 대상 (인물 이름 또는 장소 이름)",
+            "type": "관계 유형 (예: 친구, 적, 연인, 거주지, 방문지 등)",
+            "description": "관계에 대한 상세 설명",
+            "event": "이 관계를 형성하거나 변화시킨 사건 (있는 경우)"
+        }}
+    ],
+    "events": [
+        {{
+            "name": "사건 이름",
+            "description": "사건에 대한 상세 설명",
+            "participants": ["관련 인물1", "관련 인물2"],
+            "location": "사건이 발생한 장소",
+            "significance": "사건의 중요도 (예: 주요 사건, 부수 사건 등)"
+        }}
+    ]
+}}
+
+중요 사항:
+1. 엔티티는 이 회차에서 실제로 등장하거나 언급된 인물과 장소만 추출하세요.
+2. 관계는 이 회차에서 새로 형성되거나 변화한 관계를 중심으로 추출하세요.
+3. 사건은 이 회차에서 일어난 구체적인 사건들을 추출하세요.
+4. 응답은 오직 JSON 형식만 사용하고, 다른 설명이나 마크다운은 포함하지 마세요.
+5. JSON 형식이 올바른지 반드시 확인하세요 (따옴표 이스케이프 등).
+6. 배열이 비어있을 경우 빈 배열 []로 표시하세요.
+7. 필드 값이 없는 경우 null 대신 빈 문자열 "" 또는 빈 배열 []을 사용하세요."""
+    
+    return prompt
+

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, ParentChunk, SystemConfig, EpisodeAnalysis
+from app.database import db, UploadedFile, User, ChatSession, ChatMessage, DocumentChunk, ParentChunk, SystemConfig, EpisodeAnalysis, GraphEntity, GraphRelationship, GraphEvent
 from app.vector_db import get_vector_db
 from app.gemini_client import get_gemini_client
 import requests
@@ -603,6 +603,216 @@ def analyze_episode(episode_content, episode_title, full_content=None, parent_ch
         traceback.print_exc()
         return f"## {episode_title} 분석\n분석 중 오류가 발생했습니다: {str(e)}"
 
+def extract_graph_from_episode(episode_content, episode_title, file_id, full_content=None, parent_chunk=None, model_name=None):
+    """회차별 Graph Extraction (엔티티와 관계 추출)
+    
+    Args:
+        episode_content: 분석할 회차 내용
+        episode_title: 회차 제목 (예: '1화', '2화')
+        file_id: 파일 ID
+        full_content: 원본 웹소설 전체 내용 (참고용)
+        parent_chunk: Parent Chunk 객체 (선택사항)
+        model_name: 사용할 AI 모델명
+    
+    Returns:
+        추출 성공 여부 (bool)
+    """
+    try:
+        print(f"[Graph Extraction] '{episode_title}' Graph Extraction 시작...")
+        
+        # Parent Chunk 정보 추가
+        parent_info = ""
+        if parent_chunk:
+            parent_info = f"""
+작품 전체 정보:
+- 세계관: {parent_chunk.world_view or '없음'}
+- 주요 캐릭터: {parent_chunk.characters or '없음'}
+- 주요 스토리: {parent_chunk.story or '없음'}
+"""
+        
+        # Graph Extraction 프롬프트 생성
+        from app.prompts.graph_extraction import get_graph_extraction_prompt
+        
+        prompt = get_graph_extraction_prompt(
+            episode_content=episode_content,
+            episode_title=episode_title,
+            full_content=full_content,
+            parent_chunk_info=parent_info,
+            max_length=10000
+        )
+        
+        # 모델명이 없으면 기본값 사용 (Gemini 우선 시도)
+        response_text = None
+        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=3000
+                    )
+                    if not result['error'] and result.get('response'):
+                        response_text = result['response'].strip()
+            except Exception as e:
+                print(f"[Graph Extraction] Gemini 기본 모델 오류: {str(e)}")
+        
+        # 모델명이 있거나 Gemini 실패 시 해당 모델 사용
+        if not response_text and 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=3000
+                    )
+                    if not result['error'] and result.get('response'):
+                        response_text = result['response'].strip()
+            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': 3000
+                            }
+                        },
+                        timeout=300  # 5분 타임아웃
+                    )
+                    if ollama_response.status_code == 200:
+                        response_data = ollama_response.json()
+                        response_text = response_data.get('response', '').strip()
+                except requests.exceptions.Timeout:
+                    print(f"[Graph Extraction] Ollama 타임아웃: 요청 시간이 초과되었습니다. (5분)")
+                except requests.exceptions.ConnectionError:
+                    print(f"[Graph Extraction] Ollama 연결 오류: Ollama 서버에 연결할 수 없습니다.")
+                except Exception as e:
+                    print(f"[Graph Extraction] Ollama 오류: {str(e)}")
+        
+        if not response_text:
+            print(f"[Graph Extraction] '{episode_title}' Graph Extraction 실패: 응답 없음")
+            return False
+        
+        # JSON 추출
+        json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+        if not json_match:
+            print(f"[Graph Extraction] '{episode_title}' Graph Extraction 실패: JSON 형식이 아닙니다")
+            print(f"[Graph Extraction] 응답 일부: {response_text[:500]}")
+            return False
+        
+        try:
+            graph_data = json.loads(json_match.group(0))
+        except json.JSONDecodeError as e:
+            print(f"[Graph Extraction] '{episode_title}' JSON 파싱 오류: {str(e)}")
+            print(f"[Graph Extraction] 응답 일부: {response_text[:500]}")
+            return False
+        
+        # 기존 Graph 데이터 삭제 (같은 회차의 기존 데이터)
+        GraphEntity.query.filter_by(file_id=file_id, episode_title=episode_title).delete()
+        GraphRelationship.query.filter_by(file_id=file_id, episode_title=episode_title).delete()
+        GraphEvent.query.filter_by(file_id=file_id, episode_title=episode_title).delete()
+        db.session.commit()
+        
+        # 데이터베이스에 저장
+        saved_count = 0
+        
+        # 엔티티 저장
+        entities = graph_data.get('entities', {})
+        
+        # 인물 저장
+        characters = entities.get('characters', [])
+        for char in characters:
+            if char.get('name'):
+                entity = GraphEntity(
+                    file_id=file_id,
+                    episode_title=episode_title,
+                    entity_name=char.get('name', ''),
+                    entity_type='character',
+                    description=char.get('description'),
+                    role=char.get('role'),
+                    category=None
+                )
+                db.session.add(entity)
+                saved_count += 1
+        
+        # 장소 저장
+        locations = entities.get('locations', [])
+        for loc in locations:
+            if loc.get('name'):
+                entity = GraphEntity(
+                    file_id=file_id,
+                    episode_title=episode_title,
+                    entity_name=loc.get('name', ''),
+                    entity_type='location',
+                    description=loc.get('description'),
+                    role=None,
+                    category=loc.get('category')
+                )
+                db.session.add(entity)
+                saved_count += 1
+        
+        # 관계 저장
+        relationships = graph_data.get('relationships', [])
+        for rel in relationships:
+            if rel.get('source') and rel.get('target'):
+                relationship = GraphRelationship(
+                    file_id=file_id,
+                    episode_title=episode_title,
+                    source=rel.get('source', ''),
+                    target=rel.get('target', ''),
+                    relationship_type=rel.get('type', ''),
+                    description=rel.get('description'),
+                    event=rel.get('event')
+                )
+                db.session.add(relationship)
+                saved_count += 1
+        
+        # 사건 저장
+        events = graph_data.get('events', [])
+        for event in events:
+            if event.get('name') or event.get('description'):
+                participants = event.get('participants', [])
+                participants_json = json.dumps(participants, ensure_ascii=False) if participants else None
+                
+                graph_event = GraphEvent(
+                    file_id=file_id,
+                    episode_title=episode_title,
+                    event_name=event.get('name', ''),
+                    description=event.get('description', ''),
+                    participants=participants_json,
+                    location=event.get('location'),
+                    significance=event.get('significance')
+                )
+                db.session.add(graph_event)
+                saved_count += 1
+        
+        db.session.commit()
+        print(f"[Graph Extraction] '{episode_title}' Graph Extraction 완료: {saved_count}개 항목 저장")
+        return True
+        
+    except Exception as e:
+        print(f"[Graph Extraction] '{episode_title}' Graph Extraction 오류: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        db.session.rollback()
+        return False
+
 def create_chunks_for_file(file_id, content):
     """파일 내용을 섹션별로 분할하여 의미 기반 ��크로 저장 (벡터 DB 포함)
     
@@ -703,6 +913,33 @@ def create_chunks_for_file(file_id, content):
                 db.session.add(episode_analysis)
                 db.session.commit()
                 print(f"[회차 분석] 완료: {len(episode_sections)}개 회차 분석 결과를 하나의 텍스트로 저장")
+                
+                # 회차별 Graph Extraction 실행
+                print(f"[Graph Extraction] 회차별 Graph Extraction 시작...")
+                graph_extraction_success_count = 0
+                for section_type, section_title, section_content, section_metadata in episode_sections:
+                    try:
+                        print(f"[Graph Extraction] '{section_title}' Graph Extraction 중...")
+                        success = extract_graph_from_episode(
+                            episode_content=section_content,
+                            episode_title=section_title,
+                            file_id=file_id,
+                            full_content=content,
+                            parent_chunk=parent_chunk,
+                            model_name=model_name
+                        )
+                        if success:
+                            graph_extraction_success_count += 1
+                            print(f"[Graph Extraction] '{section_title}' Graph Extraction 완료")
+                        else:
+                            print(f"[Graph Extraction] '{section_title}' Graph Extraction 실패")
+                    except Exception as e:
+                        print(f"[Graph Extraction] '{section_title}' Graph Extraction 중 오류: {str(e)}")
+                        import traceback
+                        traceback.print_exc()
+                        continue
+                
+                print(f"[Graph Extraction] 완료: {graph_extraction_success_count}/{len(episode_sections)}개 회차 Graph Extraction 성공")
             else:
                 print(f"[회차 분석] 경고: 분석 결과가 없습니다.")
         else:
@@ -1074,6 +1311,129 @@ def get_episode_analyses_for_files(file_ids):
         print(f"[회차별 분석 조회] 오류: {str(e)}")
         return []
 
+def get_relevant_graph_data(query, file_ids=None):
+    """질문과 관련된 GraphRAG 데이터 조회 (엔티티, 관계, 사건)
+    
+    Args:
+        query: 사용자 질문
+        file_ids: 파일 ID 목록 (None이면 모든 파일)
+    
+    Returns:
+        dict: {
+            'entities': [...],
+            'relationships': [...],
+            'events': [...],
+            'episodes': [...]
+        }
+    """
+    try:
+        if not file_ids:
+            return {
+                'entities': [],
+                'relationships': [],
+                'events': [],
+                'episodes': []
+            }
+        
+        # 질문에서 키워드 추출 (한글 단어, 영문 단어)
+        query_words = set(re.findall(r'[가-힣]+|\w+', query.lower()))
+        
+        # 파일 ID 확장 (이어서 업로드된 파일 포함)
+        expanded_file_ids = list(file_ids)
+        for file_id in file_ids:
+            child_files = UploadedFile.query.filter_by(parent_file_id=file_id).all()
+            expanded_file_ids.extend([child.id for child in child_files])
+        
+        # 엔티티 검색 (인물, 장소 이름이 질문에 포함된 경우)
+        entities = []
+        if query_words:
+            # 엔티티 이름에 질문의 키워드가 포함된 경우
+            entity_query = GraphEntity.query.filter(
+                GraphEntity.file_id.in_(expanded_file_ids)
+            )
+            
+            # 키워드 매칭 (엔티티 이름이나 설명에 포함)
+            matching_entities = []
+            for entity in entity_query.all():
+                entity_name_lower = entity.entity_name.lower()
+                entity_desc_lower = (entity.description or '').lower()
+                
+                # 엔티티 이름이나 설명에 질문 키워드가 포함되어 있는지 확인
+                if any(word in entity_name_lower or word in entity_desc_lower for word in query_words if len(word) > 1):
+                    matching_entities.append(entity)
+            
+            entities = matching_entities[:20]  # 최대 20개
+        
+        # 관계 검색 (관계의 주체나 대상이 질문에 포함된 경우)
+        relationships = []
+        if query_words:
+            relationship_query = GraphRelationship.query.filter(
+                GraphRelationship.file_id.in_(expanded_file_ids)
+            )
+            
+            matching_relationships = []
+            for rel in relationship_query.all():
+                source_lower = rel.source.lower()
+                target_lower = rel.target.lower()
+                rel_type_lower = rel.relationship_type.lower()
+                rel_desc_lower = (rel.description or '').lower()
+                
+                # 관계의 주체, 대상, 유형, 설명에 질문 키워드가 포함되어 있는지 확인
+                if any(word in source_lower or word in target_lower or word in rel_type_lower or word in rel_desc_lower 
+                       for word in query_words if len(word) > 1):
+                    matching_relationships.append(rel)
+            
+            relationships = matching_relationships[:20]  # 최대 20개
+        
+        # 사건 검색 (사건 이름이나 설명에 질문 키워드가 포함된 경우)
+        events = []
+        if query_words:
+            event_query = GraphEvent.query.filter(
+                GraphEvent.file_id.in_(expanded_file_ids)
+            )
+            
+            matching_events = []
+            for event in event_query.all():
+                event_name_lower = (event.event_name or '').lower()
+                event_desc_lower = (event.description or '').lower()
+                event_location_lower = (event.location or '').lower()
+                
+                # 사건 이름, 설명, 장소에 질문 키워드가 포함되어 있는지 확인
+                if any(word in event_name_lower or word in event_desc_lower or word in event_location_lower 
+                       for word in query_words if len(word) > 1):
+                    matching_events.append(event)
+            
+            events = matching_events[:20]  # 최대 20개
+        
+        # 관련 회차 추출
+        episodes = set()
+        for entity in entities:
+            episodes.add(entity.episode_title)
+        for rel in relationships:
+            episodes.add(rel.episode_title)
+        for event in events:
+            episodes.add(event.episode_title)
+        
+        print(f"[GraphRAG 검색] 관련 데이터 발견: 엔티티 {len(entities)}개, 관계 {len(relationships)}개, 사건 {len(events)}개, 회차 {len(episodes)}개")
+        
+        return {
+            'entities': [e.to_dict() for e in entities],
+            'relationships': [r.to_dict() for r in relationships],
+            'events': [ev.to_dict() for ev in events],
+            'episodes': sorted(list(episodes))
+        }
+        
+    except Exception as e:
+        print(f"[GraphRAG 검색] 오류: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return {
+            'entities': [],
+            'relationships': [],
+            'events': [],
+            'episodes': []
+        }
+
 def search_relevant_chunks(query, file_ids=None, model_name=None, top_k=5, min_score=1):
     """
     질문과 관련된 청크 검색 (벡터 검색 + Re-ranking)
@@ -1750,8 +2110,18 @@ def chat():
                         episode_analyses = get_episode_analyses_for_files(file_ids)
                         print(f"[RAG 검색 1단계] 회차별 분석 조회 완료: {len(episode_analyses)}개 파일")
                     
-                    # 2단계: 벡터 검색 + 리랭킹으로 Child Chunk 정밀 검색
-                    print(f"[RAG 검색 2단계] 벡터 검색 + 리랭킹 시작...")
+                    # 2단계: GraphRAG 데이터 조회 (엔티티, 관계, 사건)
+                    graph_data = None
+                    if file_ids:
+                        print(f"[RAG 검색 2단계] GraphRAG 데이터 조회 시작...")
+                        graph_data = get_relevant_graph_data(
+                            query=message,
+                            file_ids=file_ids
+                        )
+                        print(f"[RAG 검색 2단계] GraphRAG 데이터 조회 완료: 엔티티 {len(graph_data['entities'])}개, 관계 {len(graph_data['relationships'])}개, 사건 {len(graph_data['events'])}개")
+                    
+                    # 3단계: 벡터 검색 + 리랭킹으로 Child Chunk 정밀 검색
+                    print(f"[RAG 검색 3단계] 벡터 검색 + 리랭킹 시작...")
                     relevant_chunks = search_relevant_chunks(
                         query=message,
                         file_ids=file_ids if file_ids else None,
@@ -1759,11 +2129,113 @@ def chat():
                         top_k=5,  # 리랭킹 후 상위 5개만 선택
                         min_score=0.5  # 최소 점수 임계값
                     )
-                    print(f"[RAG 검색 2단계] 벡터 검색 + 리랭킹 완료: {len(relevant_chunks)}개 청크 (상위 5개)")
+                    print(f"[RAG 검색 3단계] 벡터 검색 + 리랭킹 완료: {len(relevant_chunks)}개 청크 (상위 5개)")
                     
                     # 컨텍스트 구성
                     context_parts = []
                     
+                    # GraphRAG 데이터 추가 (엔티티, 관계, 사건 정보)
+                    if graph_data and (graph_data['entities'] or graph_data['relationships'] or graph_data['events']):
+                        graph_context_parts = []
+                        
+                        # 엔티티 정보
+                        if graph_data['entities']:
+                            entity_sections = {}
+                            for entity in graph_data['entities']:
+                                episode = entity.get('episode_title', '기타')
+                                if episode not in entity_sections:
+                                    entity_sections[episode] = {'characters': [], 'locations': []}
+                                
+                                if entity.get('entity_type') == 'character':
+                                    entity_sections[episode]['characters'].append(entity)
+                                elif entity.get('entity_type') == 'location':
+                                    entity_sections[episode]['locations'].append(entity)
+                            
+                            entity_text = "다음은 질문과 관련된 등장인물 및 장소 정보입니다:\n\n"
+                            for episode, entities in entity_sections.items():
+                                entity_text += f"=== {episode} ===\n"
+                                
+                                if entities['characters']:
+                                    entity_text += "인물:\n"
+                                    for char in entities['characters']:
+                                        entity_text += f"- {char.get('entity_name', '')}"
+                                        if char.get('role'):
+                                            entity_text += f" (역할: {char.get('role')})"
+                                        if char.get('description'):
+                                            entity_text += f": {char.get('description')}"
+                                        entity_text += "\n"
+                                
+                                if entities['locations']:
+                                    entity_text += "장소:\n"
+                                    for loc in entities['locations']:
+                                        entity_text += f"- {loc.get('entity_name', '')}"
+                                        if loc.get('category'):
+                                            entity_text += f" (유형: {loc.get('category')})"
+                                        if loc.get('description'):
+                                            entity_text += f": {loc.get('description')}"
+                                        entity_text += "\n"
+                                
+                                entity_text += "\n"
+                            
+                            graph_context_parts.append(entity_text)
+                        
+                        # 관계 정보
+                        if graph_data['relationships']:
+                            rel_sections = {}
+                            for rel in graph_data['relationships']:
+                                episode = rel.get('episode_title', '기타')
+                                if episode not in rel_sections:
+                                    rel_sections[episode] = []
+                                rel_sections[episode].append(rel)
+                            
+                            rel_text = "다음은 질문과 관련된 인물/장소 간의 관계 정보입니다:\n\n"
+                            for episode, rels in rel_sections.items():
+                                rel_text += f"=== {episode} ===\n"
+                                for rel in rels:
+                                    rel_text += f"- {rel.get('source', '')} → {rel.get('target', '')}"
+                                    if rel.get('relationship_type'):
+                                        rel_text += f" ({rel.get('relationship_type')})"
+                                    if rel.get('description'):
+                                        rel_text += f": {rel.get('description')}"
+                                    if rel.get('event'):
+                                        rel_text += f" [관련 사건: {rel.get('event')}]"
+                                    rel_text += "\n"
+                                rel_text += "\n"
+                            
+                            graph_context_parts.append(rel_text)
+                        
+                        # 사건 정보
+                        if graph_data['events']:
+                            event_sections = {}
+                            for event in graph_data['events']:
+                                episode = event.get('episode_title', '기타')
+                                if episode not in event_sections:
+                                    event_sections[episode] = []
+                                event_sections[episode].append(event)
+                            
+                            event_text = "다음은 질문과 관련된 주요 사건 정보입니다:\n\n"
+                            for episode, events in event_sections.items():
+                                event_text += f"=== {episode} ===\n"
+                                for event in events:
+                                    if event.get('event_name'):
+                                        event_text += f"- {event.get('event_name')}\n"
+                                    if event.get('description'):
+                                        event_text += f"  설명: {event.get('description')}\n"
+                                    if event.get('participants') and len(event.get('participants', [])) > 0:
+                                        event_text += f"  관련 인물: {', '.join(event.get('participants', []))}\n"
+                                    if event.get('location'):
+                                        event_text += f"  장소: {event.get('location')}\n"
+                                    if event.get('significance'):
+                                        event_text += f"  중요도: {event.get('significance')}\n"
+                                    event_text += "\n"
+                            
+                            graph_context_parts.append(event_text)
+                        
+                        if graph_context_parts:
+                            graph_context = "\n\n".join(graph_context_parts)
+                            context_parts.append(f"다음은 질문과 관련된 GraphRAG 데이터입니다 (엔티티, 관계, 사건 정보):\n\n{graph_context}")
+                            print(f"[RAG 검색] GraphRAG 컨텍스트 추가: {len(graph_context)}자")
+                    
                     # 회차별 분석 정보 추가 (회차별 요약 참조용)
                     if episode_analyses:
                         episode_context_sections = []
@@ -1816,8 +2288,27 @@ def chat():
                     if context_parts:
                         full_context = "\n\n" + "\n\n---\n\n".join(context_parts) + "\n\n"
                         
-                        # 회차별 분석과 Child Chunk 모두 있는 경우
-                        if episode_analyses and relevant_chunks:
+                        # 회차별 분석, GraphRAG, Child Chunk 모두 있는 경우
+                        has_graph = graph_data and (graph_data['entities'] or graph_data['relationships'] or graph_data['events'])
+                        
+                        if episode_analyses and has_graph and relevant_chunks:
+                            context = f"""다음은 질문에 답하기 위한 웹소설 정보입니다:
+
+{full_context}
+
+위 정보를 참고하여 답변해주세요:
+- 먼저 GraphRAG 데이터(엔티티, 관계, 사건)를 확인하여 등장인물, 장소, 인물 간의 관계, 주요 사건을 파악하세요.
+- 그 다음 회차별 분석 내용을 이해하여 각 회차의 주요 스토리, 등장 인물, 인물 관계 변화를 파악하세요.
+- 마지막으로 구체적인 내용(Child Chunk)을 통해 질문에 대한 정확한 답변을 제공하세요.
+- 웹소설의 맥락과 스토리를 고려하여 일관성 있는 답변을 작성하세요.
+
+중요: 질문에 답변할 때는 반드시 제공된 [소설 본문] 내의 내용을 근거로 해야 합니다.
+답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
+근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
+
+질문:
+"""
+                        elif episode_analyses and relevant_chunks:
                             context = f"""다음은 질문에 답하기 위한 웹소설 정보입니다:
 
 {full_context}
@@ -1831,6 +2322,38 @@ def chat():
 답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
 근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
 
+질문:
+"""
+                        elif has_graph and relevant_chunks:
+                            context = f"""다음은 질문에 답하기 위한 웹소설 정보입니다:
+
+{full_context}
+
+위 정보를 참고하여 답변해주세요:
+- 먼저 GraphRAG 데이터(엔티티, 관계, 사건)를 확인하여 등장인물, 장소, 인물 간의 관계, 주요 사건을 파악하세요.
+- 그 다음 구체적인 내용(Child Chunk)을 통해 질문에 대한 정확한 답변을 제공하세요.
+- 웹소설의 맥락과 스토리를 고려하여 일관성 있는 답변을 작성하세요.
+
+중요: 질문에 답변할 때는 반드시 제공된 [소설 본문] 내의 내용을 근거로 해야 합니다.
+답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
+근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
+
+질문:
+"""
+                        elif episode_analyses and has_graph:
+                            # 회차별 분석과 GraphRAG만 있는 경우
+                            context = f"""다음은 웹소설의 회차별 상세 분석 및 GraphRAG 데이터입니다:
+
+{full_context}
+
+위 정보를 참고하여 질문에 답변해주세요:
+- GraphRAG 데이터(엔티티, 관계, 사건)를 확인하여 등장인물, 장소, 인물 간의 관계, 주요 사건을 파악하세요.
+- 회차별 분석 내용을 이해하여 각 회차의 주요 스토리, 등장 인물, 인물 관계 변화를 고려하여 답변하세요.
+
+중요: 질문에 답변할 때는 반드시 제공된 [소설 본문] 내의 내용을 근거로 해야 합니다.
+답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
+근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
+
 질문:
 """
                         elif episode_analyses:
@@ -1845,6 +2368,22 @@ def chat():
 답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
 근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
 
+질문:
+"""
+                        elif has_graph:
+                            # GraphRAG만 있는 경우
+                            context = f"""다음은 질문과 관련된 GraphRAG 데이터입니다 (엔티티, 관계, 사건 정보):
+
+{full_context}
+
+위 정보를 참고하여 질문에 답변해주세요:
+- GraphRAG 데이터를 확인하여 등장인물, 장소, 인물 간의 관계, 주요 사건을 파악하세요.
+- 웹소설의 맥락과 스토리를 고려하여 일관성 있는 답변을 작성하세요.
+
+중요: 질문에 답변할 때는 반드시 제공된 [소설 본문] 내의 내용을 근거로 해야 합니다.
+답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
+근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
+
 질문:
 """
                         else:
@@ -1863,7 +2402,8 @@ def chat():
 """
                         
                         context += message
-                        print(f"[RAG 검색] 최종 컨텍스트 생성 완료 (회차별 분석: {len(episode_analyses)}개, Child Chunk: {len(relevant_chunks)}개, 총 {len(context)}자)")
+                        graph_info = f", GraphRAG: {len(graph_data['entities']) if graph_data else 0}개 엔티티, {len(graph_data['relationships']) if graph_data else 0}개 관계, {len(graph_data['events']) if graph_data else 0}개 사건" if graph_data else ""
+                        print(f"[RAG 검색] 최종 컨텍스트 생성 완료 (회차별 분석: {len(episode_analyses)}개{graph_info}, Child Chunk: {len(relevant_chunks)}개, 총 {len(context)}자)")
                     else:
                         # RAG 검색 결과가 없으면 기존 방식 사용
                         print(f"[RAG 검색] 관련 청크를 찾지 못했습니다. 전체 파일 내용 사용")
@@ -2603,6 +3143,79 @@ def get_file_summary(file_id):
     except Exception as e:
         return jsonify({'error': f'요약 내용 조회 중 오류가 발생했습니다: {str(e)}'}), 500
 
+@main_bp.route('/api/files/<int:file_id>/graph', methods=['GET'])
+@login_required
+def get_file_graph(file_id):
+    """파일의 GraphRAG 데이터 조회 (엔티티, 관계, 사건)"""
+    try:
+        print(f"[GraphRAG 조회] 파일 ID {file_id} GraphRAG 데이터 조회 요청 (사용자: {current_user.username})")
+        
+        file = UploadedFile.query.get(file_id)
+        
+        if not file:
+            print(f"[GraphRAG 조회] 파일을 찾을 수 없음: 파일 ID {file_id}")
+            return jsonify({'error': f'파일을 찾을 수 없습니다. (파일 ID: {file_id})'}), 404
+        
+        # 엔티티 조회 (회차별로 그룹화)
+        entities = GraphEntity.query.filter_by(file_id=file_id).all()
+        entities_by_episode = {}
+        for entity in entities:
+            episode = entity.episode_title
+            if episode not in entities_by_episode:
+                entities_by_episode[episode] = {'characters': [], 'locations': []}
+            
+            if entity.entity_type == 'character':
+                entities_by_episode[episode]['characters'].append(entity.to_dict())
+            elif entity.entity_type == 'location':
+                entities_by_episode[episode]['locations'].append(entity.to_dict())
+        
+        # 관계 조회 (회차별로 그룹화)
+        relationships = GraphRelationship.query.filter_by(file_id=file_id).all()
+        relationships_by_episode = {}
+        for rel in relationships:
+            episode = rel.episode_title
+            if episode not in relationships_by_episode:
+                relationships_by_episode[episode] = []
+            relationships_by_episode[episode].append(rel.to_dict())
+        
+        # 사건 조회 (회차별로 그룹화)
+        events = GraphEvent.query.filter_by(file_id=file_id).all()
+        events_by_episode = {}
+        for event in events:
+            episode = event.episode_title
+            if episode not in events_by_episode:
+                events_by_episode[episode] = []
+            events_by_episode[episode].append(event.to_dict())
+        
+        # 통계 정보
+        total_entities = len(entities)
+        total_relationships = len(relationships)
+        total_events = len(events)
+        episodes = list(set([e.episode_title for e in entities] + 
+                           [r.episode_title for r in relationships] + 
+                           [ev.episode_title for ev in events]))
+        
+        return jsonify({
+            'file_id': file_id,
+            'filename': file.original_filename,
+            'statistics': {
+                'total_entities': total_entities,
+                'total_relationships': total_relationships,
+                'total_events': total_events,
+                'episodes_count': len(episodes)
+            },
+            'entities_by_episode': entities_by_episode,
+            'relationships_by_episode': relationships_by_episode,
+            'events_by_episode': events_by_episode,
+            'episodes': sorted(episodes)
+        }), 200
+        
+    except Exception as e:
+        print(f"[GraphRAG 조회] 오류: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({'error': f'GraphRAG 데이터 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
 @main_bp.route('/api/files/<int:file_id>/parent-chunk', methods=['GET'])
 @login_required
 def get_file_parent_chunk(file_id):

templates/admin_files.html

@@ -413,6 +413,61 @@
         </div>
     </div>
 
+    <!-- GraphRAG 모달 -->
+    <div id="graphRAGModal" class="modal">
+        <div class="modal-content" style="max-width: 1400px;">
+            <div class="modal-header">
+                <div class="modal-title" id="graphRAGModalTitle">GraphRAG 데이터</div>
+                <button class="modal-close" onclick="closeGraphRAGModal()">&times;</button>
+            </div>
+            <div id="graphRAGContent" style="max-height: 80vh; overflow-y: auto;">
+                <div style="text-align: center; padding: 24px; color: #5f6368;">
+                    GraphRAG 데이터를 불러오는 중...
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- GraphRAG 그래프 시각화 모달 -->
+    <div id="graphRAGVisualizationModal" class="modal">
+        <div class="modal-content" style="max-width: 1600px; width: 95%; height: 90vh;">
+            <div class="modal-header">
+                <div class="modal-title" id="graphRAGVisualizationModalTitle">GraphRAG 그래프 시각화</div>
+                <button class="modal-close" onclick="closeGraphRAGVisualizationModal()">&times;</button>
+            </div>
+            <div style="padding: 16px; border-bottom: 1px solid #dadce0; background: #f8f9fa; display: flex; gap: 12px; align-items: center; flex-wrap: wrap;">
+                <label style="font-size: 14px; font-weight: 500;">회차 필터:</label>
+                <select id="episodeFilter" onchange="updateGraphVisualization()" style="padding: 6px 12px; border: 1px solid #dadce0; border-radius: 6px; font-size: 14px; min-width: 200px;">
+                    <option value="all">전체 회차</option>
+                </select>
+                <label style="font-size: 14px; font-weight: 500; margin-left: 16px;">노드 타입:</label>
+                <label style="font-size: 13px; margin-left: 8px;">
+                    <input type="checkbox" id="showCharacters" checked onchange="updateGraphVisualization()" style="margin-right: 4px;">
+                    인물
+                </label>
+                <label style="font-size: 13px; margin-left: 8px;">
+                    <input type="checkbox" id="showLocations" checked onchange="updateGraphVisualization()" style="margin-right: 4px;">
+                    장소
+                </label>
+                <label style="font-size: 13px; margin-left: 8px;">
+                    <input type="checkbox" id="showEvents" checked onchange="updateGraphVisualization()" style="margin-right: 4px;">
+                    사건
+                </label>
+                <button onclick="resetGraphView()" style="padding: 6px 16px; background: #1a73e8; color: white; border: none; border-radius: 6px; cursor: pointer; font-size: 13px; margin-left: auto;">
+                    뷰 리셋
+                </button>
+            </div>
+            <div id="graphRAGVisualizationContent" style="height: calc(90vh - 120px); position: relative; background: #ffffff;">
+                <div style="text-align: center; padding: 24px; color: #5f6368; position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);">
+                    그래프를 불러오는 중...
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- vis-network 라이브러리 -->
+    <script type="text/javascript" src="https://unpkg.com/vis-network@latest/standalone/umd/vis-network.min.js"></script>
+
     <script>
         function escapeHtml(text) {
             const div = document.createElement('div');
@@ -515,7 +570,9 @@
                         <td>
                             <div class="file-actions">
                                 <button class="btn btn-secondary" onclick="viewSummary(${file.id}, '${escapeHtml(file.original_filename)}')" style="padding: 4px 8px; font-size: 12px; margin-right: 4px;">요약 내용 보기</button>
-                                <button class="btn btn-info" onclick="viewChunks(${file.id}, '${escapeHtml(file.original_filename)}')" style="padding: 4px 8px; font-size: 12px;">청크 보기</button>
+                                <button class="btn btn-info" onclick="viewChunks(${file.id}, '${escapeHtml(file.original_filename)}')" style="padding: 4px 8px; font-size: 12px; margin-right: 4px;">청크 보기</button>
+                                <button class="btn btn-primary" onclick="viewGraphRAG(${file.id}, '${escapeHtml(file.original_filename)}')" style="padding: 4px 8px; font-size: 12px; margin-right: 4px;">GraphRAG 보기</button>
+                                <button class="btn btn-success" onclick="viewGraphRAGVisualization(${file.id}, '${escapeHtml(file.original_filename)}')" style="padding: 4px 8px; font-size: 12px;">그래프 시각화</button>
                             </div>
                         </td>
                     `;
@@ -709,6 +766,518 @@
             document.getElementById('chunkContentModal').classList.remove('active');
         }
 
+        async function viewGraphRAG(fileId, fileName) {
+            const modal = document.getElementById('graphRAGModal');
+            const title = document.getElementById('graphRAGModalTitle');
+            const content = document.getElementById('graphRAGContent');
+            
+            title.textContent = `GraphRAG 데이터 - ${fileName}`;
+            content.innerHTML = '<div style="text-align: center; padding: 24px; color: #5f6368;">GraphRAG 데이터를 불러오는 중...</div>';
+            modal.classList.add('active');
+            
+            try {
+                const response = await fetch(`/api/files/${fileId}/graph`, {
+                    credentials: 'include'
+                });
+                if (!response.ok) throw new Error('GraphRAG 데이터를 불러올 수 없습니다.');
+                
+                const data = await response.json();
+                
+                let contentHtml = '';
+                
+                // 통계 정보
+                if (data.statistics) {
+                    contentHtml += '<div style="margin-bottom: 32px; padding: 16px; background: #e8f0fe; border-radius: 6px;">';
+                    contentHtml += '<h3 style="font-size: 18px; font-weight: 600; margin-bottom: 16px; color: #1a73e8;">통계 정보</h3>';
+                    contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 16px;">';
+                    contentHtml += `<div style="padding: 12px; background: white; border-radius: 6px;"><strong>엔티티:</strong> ${data.statistics.total_entities}개</div>`;
+                    contentHtml += `<div style="padding: 12px; background: white; border-radius: 6px;"><strong>관계:</strong> ${data.statistics.total_relationships}개</div>`;
+                    contentHtml += `<div style="padding: 12px; background: white; border-radius: 6px;"><strong>사건:</strong> ${data.statistics.total_events}개</div>`;
+                    contentHtml += `<div style="padding: 12px; background: white; border-radius: 6px;"><strong>회차 수:</strong> ${data.statistics.episodes_count}개</div>`;
+                    contentHtml += '</div>';
+                    contentHtml += '</div>';
+                }
+                
+                // 회차별 데이터 표시
+                const episodes = data.episodes || [];
+                
+                if (episodes.length === 0) {
+                    contentHtml += '<div style="text-align: center; padding: 24px; color: #5f6368;">GraphRAG 데이터가 없습니다.</div>';
+                } else {
+                    episodes.forEach(episode => {
+                        contentHtml += `<div style="margin-bottom: 32px; padding: 20px; background: #f8f9fa; border-radius: 8px; border-left: 4px solid #1a73e8;">`;
+                        contentHtml += `<h3 style="font-size: 20px; font-weight: 600; margin-bottom: 20px; color: #1a73e8;">${escapeHtml(episode)}</h3>`;
+                        
+                        // 엔티티 (인물)
+                        const characters = data.entities_by_episode[episode]?.characters || [];
+                        if (characters.length > 0) {
+                            contentHtml += '<div style="margin-bottom: 20px;">';
+                            contentHtml += '<h4 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; color: #1967d2;">인물</h4>';
+                            contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 12px;">';
+                            characters.forEach(char => {
+                                contentHtml += '<div style="padding: 12px; background: white; border-radius: 6px; border: 1px solid #e8eaed;">';
+                                contentHtml += `<div style="font-weight: 600; margin-bottom: 8px; color: #1a73e8;">${escapeHtml(char.entity_name)}</div>`;
+                                if (char.role) {
+                                    contentHtml += `<div style="font-size: 13px; color: #5f6368; margin-bottom: 4px;"><strong>역할:</strong> ${escapeHtml(char.role)}</div>`;
+                                }
+                                if (char.description) {
+                                    contentHtml += `<div style="font-size: 13px; color: #5f6368;">${escapeHtml(char.description)}</div>`;
+                                }
+                                contentHtml += '</div>';
+                            });
+                            contentHtml += '</div>';
+                            contentHtml += '</div>';
+                        }
+                        
+                        // 엔티티 (장소)
+                        const locations = data.entities_by_episode[episode]?.locations || [];
+                        if (locations.length > 0) {
+                            contentHtml += '<div style="margin-bottom: 20px;">';
+                            contentHtml += '<h4 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; color: #1967d2;">장소</h4>';
+                            contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 12px;">';
+                            locations.forEach(loc => {
+                                contentHtml += '<div style="padding: 12px; background: white; border-radius: 6px; border: 1px solid #e8eaed;">';
+                                contentHtml += `<div style="font-weight: 600; margin-bottom: 8px; color: #1a73e8;">${escapeHtml(loc.entity_name)}</div>`;
+                                if (loc.category) {
+                                    contentHtml += `<div style="font-size: 13px; color: #5f6368; margin-bottom: 4px;"><strong>유형:</strong> ${escapeHtml(loc.category)}</div>`;
+                                }
+                                if (loc.description) {
+                                    contentHtml += `<div style="font-size: 13px; color: #5f6368;">${escapeHtml(loc.description)}</div>`;
+                                }
+                                contentHtml += '</div>';
+                            });
+                            contentHtml += '</div>';
+                            contentHtml += '</div>';
+                        }
+                        
+                        // 관계
+                        const relationships = data.relationships_by_episode[episode] || [];
+                        if (relationships.length > 0) {
+                            contentHtml += '<div style="margin-bottom: 20px;">';
+                            contentHtml += '<h4 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; color: #1967d2;">관계</h4>';
+                            contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(400px, 1fr)); gap: 12px;">';
+                            relationships.forEach(rel => {
+                                contentHtml += '<div style="padding: 12px; background: white; border-radius: 6px; border: 1px solid #e8eaed;">';
+                                contentHtml += `<div style="margin-bottom: 8px;">`;
+                                contentHtml += `<span style="font-weight: 600; color: #1a73e8;">${escapeHtml(rel.source)}</span>`;
+                                contentHtml += `<span style="margin: 0 8px; color: #5f6368;">→</span>`;
+                                contentHtml += `<span style="font-weight: 600; color: #1a73e8;">${escapeHtml(rel.target)}</span>`;
+                                contentHtml += '</div>';
+                                if (rel.relationship_type) {
+                                    contentHtml += `<div style="font-size: 13px; color: #5f6368; margin-bottom: 4px;"><strong>관계 유형:</strong> ${escapeHtml(rel.relationship_type)}</div>`;
+                                }
+                                if (rel.description) {
+                                    contentHtml += `<div style="font-size: 13px; color: #5f6368; margin-bottom: 4px;">${escapeHtml(rel.description)}</div>`;
+                                }
+                                if (rel.event) {
+                                    contentHtml += `<div style="font-size: 12px; color: #856404; padding: 8px; background: #fff3cd; border-radius: 4px; margin-top: 8px;"><strong>관련 사건:</strong> ${escapeHtml(rel.event)}</div>`;
+                                }
+                                contentHtml += '</div>';
+                            });
+                            contentHtml += '</div>';
+                            contentHtml += '</div>';
+                        }
+                        
+                        // 사건
+                        const events = data.events_by_episode[episode] || [];
+                        if (events.length > 0) {
+                            contentHtml += '<div style="margin-bottom: 20px;">';
+                            contentHtml += '<h4 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; color: #1967d2;">사건</h4>';
+                            contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(400px, 1fr)); gap: 12px;">';
+                            events.forEach(event => {
+                                contentHtml += '<div style="padding: 12px; background: white; border-radius: 6px; border: 1px solid #e8eaed;">';
+                                if (event.event_name) {
+                                    contentHtml += `<div style="font-weight: 600; margin-bottom: 8px; color: #1a73e8;">${escapeHtml(event.event_name)}</div>`;
+                                }
+                                if (event.description) {
+                                    contentHtml += `<div style="font-size: 13px; color: #5f6368; margin-bottom: 8px; line-height: 1.6;">${escapeHtml(event.description)}</div>`;
+                                }
+                                if (event.participants && event.participants.length > 0) {
+                                    contentHtml += `<div style="font-size: 13px; color: #5f6368; margin-bottom: 4px;"><strong>관련 인물:</strong> ${escapeHtml(event.participants.join(', '))}</div>`;
+                                }
+                                if (event.location) {
+                                    contentHtml += `<div style="font-size: 13px; color: #5f6368; margin-bottom: 4px;"><strong>장소:</strong> ${escapeHtml(event.location)}</div>`;
+                                }
+                                if (event.significance) {
+                                    contentHtml += `<div style="font-size: 12px; color: #137333; padding: 6px; background: #e8f5e9; border-radius: 4px; margin-top: 8px; display: inline-block;"><strong>중요도:</strong> ${escapeHtml(event.significance)}</div>`;
+                                }
+                                contentHtml += '</div>';
+                            });
+                            contentHtml += '</div>';
+                            contentHtml += '</div>';
+                        }
+                        
+                        contentHtml += '</div>';
+                    });
+                }
+                
+                content.innerHTML = contentHtml;
+            } catch (error) {
+                console.error('GraphRAG 데이터 로드 오류:', error);
+                content.innerHTML = '<div style="text-align: center; padding: 24px; color: #c5221f;">GraphRAG 데이터를 불러오는 중 오류가 발생했습니다.</div>';
+                showAlert('GraphRAG 데이터를 불러오는 중 오류가 발생했습니다.', 'error');
+            }
+        }
+
+        function closeGraphRAGModal() {
+            document.getElementById('graphRAGModal').classList.remove('active');
+        }
+
+        // GraphRAG 그래프 시각화 관련 변수
+        let graphData = null;
+        let graphNetwork = null;
+        let allGraphData = null;
+
+        async function viewGraphRAGVisualization(fileId, fileName) {
+            const modal = document.getElementById('graphRAGVisualizationModal');
+            const title = document.getElementById('graphRAGVisualizationModalTitle');
+            const content = document.getElementById('graphRAGVisualizationContent');
+            
+            title.textContent = `GraphRAG 그래프 시각화 - ${fileName}`;
+            content.innerHTML = '<div style="text-align: center; padding: 24px; color: #5f6368; position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);">그래프를 불러오는 중...</div>';
+            modal.classList.add('active');
+            
+            // 기존 네트워크 제거
+            if (graphNetwork) {
+                graphNetwork.destroy();
+                graphNetwork = null;
+            }
+            
+            try {
+                const response = await fetch(`/api/files/${fileId}/graph`, {
+                    credentials: 'include'
+                });
+                if (!response.ok) throw new Error('GraphRAG 데이터를 불러올 수 없습니다.');
+                
+                const data = await response.json();
+                allGraphData = data;
+                
+                // 회차 필터 옵션 생성
+                const episodeFilter = document.getElementById('episodeFilter');
+                episodeFilter.innerHTML = '<option value="all">전체 회차</option>';
+                if (data.episodes && data.episodes.length > 0) {
+                    data.episodes.forEach(episode => {
+                        const option = document.createElement('option');
+                        option.value = episode;
+                        option.textContent = episode;
+                        episodeFilter.appendChild(option);
+                    });
+                }
+                
+                // 그래프 생성
+                createGraphVisualization(data);
+            } catch (error) {
+                console.error('GraphRAG 그래프 로드 오류:', error);
+                content.innerHTML = '<div style="text-align: center; padding: 24px; color: #c5221f; position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);">그래프를 불러오는 중 오류가 발생했습니다.</div>';
+            }
+        }
+
+        function createGraphVisualization(data, episodeFilter = 'all') {
+            const content = document.getElementById('graphRAGVisualizationContent');
+            content.innerHTML = ''; // 기존 내용 제거
+            
+            // 노드와 엣지 데이터 생성
+            const nodes = new vis.DataSet([]);
+            const edges = new vis.DataSet([]);
+            
+            const nodeMap = new Map(); // 노드 ID 매핑
+            let nodeIdCounter = 1;
+            
+            const showCharacters = document.getElementById('showCharacters').checked;
+            const showLocations = document.getElementById('showLocations').checked;
+            const showEvents = document.getElementById('showEvents').checked;
+            
+            // 필터링할 회차 목록
+            const episodes = episodeFilter === 'all' 
+                ? (data.episodes || [])
+                : [episodeFilter];
+            
+            // 엔티티 추가 (인물, 장소)
+            episodes.forEach(episode => {
+                const entities = data.entities_by_episode?.[episode] || {};
+                
+                // 인물 추가
+                if (showCharacters && entities.characters) {
+                    entities.characters.forEach(char => {
+                        const nodeId = `char_${char.entity_name}`;
+                        if (!nodeMap.has(nodeId)) {
+                            const id = nodeIdCounter++;
+                            nodeMap.set(nodeId, id);
+                            nodes.add({
+                                id: id,
+                                label: char.entity_name,
+                                title: `인물: ${char.entity_name}\n역할: ${char.role || '없음'}\n설명: ${char.description || '없음'}`,
+                                color: {
+                                    background: '#4285f4',
+                                    border: '#1967d2',
+                                    highlight: { background: '#1a73e8', border: '#1557b0' }
+                                },
+                                shape: 'ellipse',
+                                font: { size: 14, face: 'Inter' },
+                                size: 20
+                            });
+                        }
+                    });
+                }
+                
+                // 장소 추가
+                if (showLocations && entities.locations) {
+                    entities.locations.forEach(loc => {
+                        const nodeId = `loc_${loc.entity_name}`;
+                        if (!nodeMap.has(nodeId)) {
+                            const id = nodeIdCounter++;
+                            nodeMap.set(nodeId, id);
+                            nodes.add({
+                                id: id,
+                                label: loc.entity_name,
+                                title: `장소: ${loc.entity_name}\n유형: ${loc.category || '없음'}\n설명: ${loc.description || '없음'}`,
+                                color: {
+                                    background: '#34a853',
+                                    border: '#137333',
+                                    highlight: { background: '#2e7d32', border: '#1b5e20' }
+                                },
+                                shape: 'box',
+                                font: { size: 14, face: 'Inter' },
+                                size: 20
+                            });
+                        }
+                    });
+                }
+            });
+            
+            // 사건 추가
+            if (showEvents) {
+                episodes.forEach(episode => {
+                    const events = data.events_by_episode?.[episode] || [];
+                    events.forEach(event => {
+                        const eventName = event.event_name || `사건_${episode}_${events.indexOf(event)}`;
+                        const nodeId = `event_${eventName}`;
+                        if (!nodeMap.has(nodeId)) {
+                            const id = nodeIdCounter++;
+                            nodeMap.set(nodeId, id);
+                            nodes.add({
+                                id: id,
+                                label: eventName,
+                                title: `사건: ${eventName}\n설명: ${event.description || '없음'}\n관련 인물: ${event.participants ? event.participants.join(', ') : '없음'}\n장소: ${event.location || '없음'}\n중요도: ${event.significance || '없음'}`,
+                                color: {
+                                    background: '#ff9800',
+                                    border: '#f57c00',
+                                    highlight: { background: '#fb8c00', border: '#e65100' }
+                                },
+                                shape: 'diamond',
+                                font: { size: 13, face: 'Inter' },
+                                size: 25
+                            });
+                            
+                            // 사건과 관련 인물 연결
+                            if (event.participants && Array.isArray(event.participants)) {
+                                event.participants.forEach(participant => {
+                                    const participantNodeId = `char_${participant}`;
+                                    const participantId = nodeMap.get(participantNodeId);
+                                    if (participantId) {
+                                        edges.add({
+                                            from: participantId,
+                                            to: id,
+                                            label: '참여',
+                                            title: `${participant}이(가) ${eventName}에 참여`,
+                                            color: {
+                                                color: '#ff9800',
+                                                highlight: '#f57c00'
+                                            },
+                                            arrows: 'to',
+                                            font: { size: 11, align: 'middle' },
+                                            dashes: true,
+                                            smooth: {
+                                                type: 'curvedCW',
+                                                roundness: 0.3
+                                            }
+                                        });
+                                    }
+                                });
+                            }
+                            
+                            // 사건과 장소 연결
+                            if (event.location) {
+                                const locationNodeId = `loc_${event.location}`;
+                                const locationId = nodeMap.get(locationNodeId);
+                                if (locationId) {
+                                    edges.add({
+                                        from: locationId,
+                                        to: id,
+                                        label: '발생',
+                                        title: `${eventName}이(가) ${event.location}에서 발생`,
+                                        color: {
+                                            color: '#ff9800',
+                                            highlight: '#f57c00'
+                                        },
+                                        arrows: 'to',
+                                        font: { size: 11, align: 'middle' },
+                                        dashes: [5, 5],
+                                        smooth: {
+                                            type: 'curvedCW',
+                                            roundness: 0.3
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                    });
+                });
+            }
+            
+            // 관계 추가
+            episodes.forEach(episode => {
+                const relationships = data.relationships_by_episode?.[episode] || [];
+                relationships.forEach(rel => {
+                    // 소스와 타겟이 인물인지 장소인지 확인
+                    let sourceNodeId = null;
+                    let targetNodeId = null;
+                    
+                    // 소스 노드 찾기
+                    if (nodeMap.has(`char_${rel.source}`)) {
+                        sourceNodeId = nodeMap.get(`char_${rel.source}`);
+                    } else if (nodeMap.has(`loc_${rel.source}`)) {
+                        sourceNodeId = nodeMap.get(`loc_${rel.source}`);
+                    }
+                    
+                    // 타겟 노드 찾기
+                    if (nodeMap.has(`char_${rel.target}`)) {
+                        targetNodeId = nodeMap.get(`char_${rel.target}`);
+                    } else if (nodeMap.has(`loc_${rel.target}`)) {
+                        targetNodeId = nodeMap.get(`loc_${rel.target}`);
+                    }
+                    
+                    if (sourceNodeId && targetNodeId) {
+                        edges.add({
+                            from: sourceNodeId,
+                            to: targetNodeId,
+                            label: rel.relationship_type || '',
+                            title: `관계: ${rel.relationship_type || '없음'}\n설명: ${rel.description || '없음'}${rel.event ? `\n관련 사건: ${rel.event}` : ''}`,
+                            color: {
+                                color: '#ea4335',
+                                highlight: '#c5221f'
+                            },
+                            arrows: 'to',
+                            font: { size: 12, align: 'middle' },
+                            smooth: {
+                                type: 'curvedCW',
+                                roundness: 0.2
+                            }
+                        });
+                    }
+                });
+            });
+            
+            // 네트워크 생성
+            const container = document.createElement('div');
+            container.id = 'graphNetworkContainer';
+            container.style.width = '100%';
+            container.style.height = '100%';
+            content.appendChild(container);
+            
+            const graphData = {
+                nodes: nodes,
+                edges: edges
+            };
+            
+            const options = {
+                nodes: {
+                    borderWidth: 2,
+                    shadow: true,
+                    font: {
+                        size: 14,
+                        face: 'Inter'
+                    }
+                },
+                edges: {
+                    width: 2,
+                    shadow: true,
+                    font: {
+                        size: 12,
+                        align: 'middle'
+                    },
+                    arrows: {
+                        to: {
+                            enabled: true,
+                            scaleFactor: 0.8
+                        }
+                    }
+                },
+                physics: {
+                    enabled: true,
+                    stabilization: {
+                        enabled: true,
+                        iterations: 200
+                    },
+                    barnesHut: {
+                        gravitationalConstant: -2000,
+                        centralGravity: 0.1,
+                        springLength: 200,
+                        springConstant: 0.04,
+                        damping: 0.09
+                    }
+                },
+                interaction: {
+                    hover: true,
+                    tooltipDelay: 200,
+                    zoomView: true,
+                    dragView: true
+                },
+                layout: {
+                    improvedLayout: true
+                }
+            };
+            
+            graphNetwork = new vis.Network(container, graphData, options);
+            
+            // 네트워크 이벤트 리스너
+            graphNetwork.on('click', function(params) {
+                if (params.nodes.length > 0) {
+                    const nodeId = params.nodes[0];
+                    const node = nodes.get(nodeId);
+                    if (node) {
+                        console.log('선택된 노드:', node);
+                    }
+                }
+            });
+        }
+
+        function updateGraphVisualization() {
+            if (!allGraphData) return;
+            
+            const episodeFilter = document.getElementById('episodeFilter').value;
+            
+            // 기존 네트워크 제거
+            if (graphNetwork) {
+                graphNetwork.destroy();
+                graphNetwork = null;
+            }
+            
+            // 새 그래프 생성
+            createGraphVisualization(allGraphData, episodeFilter);
+        }
+
+        function resetGraphView() {
+            if (graphNetwork) {
+                graphNetwork.fit({
+                    animation: {
+                        duration: 1000,
+                        easingFunction: 'easeInOutQuad'
+                    }
+                });
+            }
+        }
+
+        function closeGraphRAGVisualizationModal() {
+            document.getElementById('graphRAGVisualizationModal').classList.remove('active');
+            if (graphNetwork) {
+                graphNetwork.destroy();
+                graphNetwork = null;
+            }
+            graphData = null;
+            allGraphData = null;
+        }
+
         // 모달 외부 클릭 시 닫기
         document.getElementById('chunksModal').addEventListener('click', function(e) {
             if (e.target === this) {
@@ -728,6 +1297,18 @@
             }
         });
 
+        document.getElementById('graphRAGModal').addEventListener('click', function(e) {
+            if (e.target === this) {
+                closeGraphRAGModal();
+            }
+        });
+
+        document.getElementById('graphRAGVisualizationModal').addEventListener('click', function(e) {
+            if (e.target === this) {
+                closeGraphRAGVisualizationModal();
+            }
+        });
+
         // 페이지 로드 시 초기화
         window.addEventListener('load', () => {
             loadModelFilter();

templates/index.html

@@ -774,6 +774,125 @@
             border-bottom-left-radius: 4px;
         }
         
+        /* 마크다운 스타일 */
+        .message.ai .message-bubble h1,
+        .message.ai .message-bubble h2,
+        .message.ai .message-bubble h3,
+        .message.ai .message-bubble h4,
+        .message.ai .message-bubble h5,
+        .message.ai .message-bubble h6 {
+            margin: 12px 0 8px 0;
+            font-weight: 600;
+            line-height: 1.3;
+        }
+        
+        .message.ai .message-bubble h1 {
+            font-size: 1.5em;
+            border-bottom: 2px solid var(--border);
+            padding-bottom: 8px;
+        }
+        
+        .message.ai .message-bubble h2 {
+            font-size: 1.3em;
+            border-bottom: 1px solid var(--border);
+            padding-bottom: 6px;
+        }
+        
+        .message.ai .message-bubble h3 {
+            font-size: 1.1em;
+        }
+        
+        .message.ai .message-bubble h4 {
+            font-size: 1em;
+        }
+        
+        .message.ai .message-bubble h5 {
+            font-size: 0.9em;
+        }
+        
+        .message.ai .message-bubble h6 {
+            font-size: 0.85em;
+        }
+        
+        .message.ai .message-bubble p {
+            margin: 8px 0;
+            line-height: 1.6;
+        }
+        
+        .message.ai .message-bubble code {
+            background: var(--bg-tertiary);
+            padding: 2px 6px;
+            border-radius: 4px;
+            font-family: 'Courier New', monospace;
+            font-size: 0.9em;
+            color: var(--accent);
+        }
+        
+        .message.ai .message-bubble pre {
+            background: var(--bg-tertiary);
+            padding: 12px;
+            border-radius: 8px;
+            overflow-x: auto;
+            margin: 12px 0;
+            border: 1px solid var(--border);
+        }
+        
+        .message.ai .message-bubble pre code {
+            background: none;
+            padding: 0;
+            color: var(--text-primary);
+            font-size: 0.85em;
+        }
+        
+        .message.ai .message-bubble ul,
+        .message.ai .message-bubble ol {
+            margin: 8px 0;
+            padding-left: 24px;
+        }
+        
+        .message.ai .message-bubble li {
+            margin: 4px 0;
+            line-height: 1.5;
+        }
+        
+        .message.ai .message-bubble blockquote {
+            border-left: 4px solid var(--accent);
+            padding-left: 16px;
+            margin: 12px 0;
+            color: var(--text-secondary);
+            font-style: italic;
+        }
+        
+        .message.ai .message-bubble hr {
+            border: none;
+            border-top: 1px solid var(--border);
+            margin: 16px 0;
+        }
+        
+        .message.ai .message-bubble a {
+            color: var(--accent);
+            text-decoration: underline;
+        }
+        
+        .message.ai .message-bubble a:hover {
+            opacity: 0.8;
+        }
+        
+        .message.ai .message-bubble img {
+            max-width: 100%;
+            height: auto;
+            border-radius: 8px;
+            margin: 12px 0;
+        }
+        
+        .message.ai .message-bubble strong {
+            font-weight: 600;
+        }
+        
+        .message.ai .message-bubble em {
+            font-style: italic;
+        }
+        
         /* 각주 스타일 */
         .footnote-ref {
             font-size: 0.75em;
@@ -1631,26 +1750,134 @@
         });
 
         // [근거: ] 형식을 각주로 변환하는 함수
+        // 마크다운을 HTML로 변환하는 함수
+        function markdownToHtml(text) {
+            if (!text) return '';
+            
+            let html = text;
+            
+            // FOOTNOTE 플레이스홀더 보호 (마크다운 변환 전에 보호)
+            // 이 부분은 formatContentWithFootnotes에서 처리하므로 여기서는 보호하지 않음
+            
+            // 코드 블록 처리 (```로 감싸진 부분) - 먼저 처리하여 다른 변환에 영향받지 않도록
+            const codeBlocks = [];
+            html = html.replace(/```([\s\S]*?)```/g, (match, code) => {
+                const placeholder = `__CODE_BLOCK_${codeBlocks.length}__`;
+                codeBlocks.push({
+                    placeholder: placeholder,
+                    html: `<pre><code>${escapeHtml(code.trim())}</code></pre>`
+                });
+                return placeholder;
+            });
+            
+            // 인라인 코드 처리 (`로 감싸진 부분) - 코드 블록이 아닌 부분만
+            const inlineCodes = [];
+            html = html.replace(/`([^`\n]+)`/g, (match, code) => {
+                const placeholder = `__INLINE_CODE_${inlineCodes.length}__`;
+                inlineCodes.push({
+                    placeholder: placeholder,
+                    html: `<code>${escapeHtml(code)}</code>`
+                });
+                return placeholder;
+            });
+            
+            // 헤더 처리 (# ## ### #### ##### ######)
+            html = html.replace(/^###### (.*$)/gim, '<h6>$1</h6>');
+            html = html.replace(/^##### (.*$)/gim, '<h5>$1</h5>');
+            html = html.replace(/^#### (.*$)/gim, '<h4>$1</h4>');
+            html = html.replace(/^### (.*$)/gim, '<h3>$1</h3>');
+            html = html.replace(/^## (.*$)/gim, '<h2>$1</h2>');
+            html = html.replace(/^# (.*$)/gim, '<h1>$1</h1>');
+            
+            // 수평선 처리 (--- 또는 ***) - 헤더 다음에 처리
+            html = html.replace(/^---$/gim, '<hr>');
+            html = html.replace(/^\*\*\*$/gim, '<hr>');
+            
+            // 인용문 처리 (>)
+            html = html.replace(/^> (.+)$/gim, '<blockquote>$1</blockquote>');
+            
+            // 순서 없는 리스트 처리 (- 또는 * 또는 +)
+            html = html.replace(/^[\*\-\+] (.+)$/gim, '<li>$1</li>');
+            // 연속된 <li> 태그를 <ul>로 감싸기
+            html = html.replace(/(<li>.*?<\/li>(?:\s*<li>.*?<\/li>)*)/gs, '<ul>$1</ul>');
+            
+            // 순서 있는 리스트 처리 (1. 2. 3.)
+            html = html.replace(/^\d+\. (.+)$/gim, '<li>$1</li>');
+            // 연속된 <li> 태그를 <ol>로 감싸기 (이미 <ul>로 감싸지지 않은 경우만)
+            html = html.replace(/(?<!<ul>)(<li>.*?<\/li>(?:\s*<li>.*?<\/li>)*)(?!<\/ul>)/gs, '<ol>$1</ol>');
+            
+            // 볼드 처리 (**text** 또는 __text__) - 코드 블록/인라인 코드가 아닌 부분만
+            html = html.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+            html = html.replace(/__(.+?)__/g, '<strong>$1</strong>');
+            
+            // 이탤릭 처리 (*text* 또는 _text_) - 볼드가 아닌 경우만
+            html = html.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '<em>$1</em>');
+            html = html.replace(/(?<!_)_([^_]+)_(?!_)/g, '<em>$1</em>');
+            
+            // 링크 처리 ([text](url))
+            html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');
+            
+            // 이미지 처리 (![alt](url))
+            html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1">');
+            
+            // 인라인 코드 플레이스홀더 복원
+            inlineCodes.forEach(({ placeholder, html: codeHtml }) => {
+                html = html.replace(placeholder, codeHtml);
+            });
+            
+            // 코드 블록 플레이스홀더 복원
+            codeBlocks.forEach(({ placeholder, html: codeHtml }) => {
+                html = html.replace(placeholder, codeHtml);
+            });
+            
+            // 줄바꿈 처리
+            // 먼저 두 개 이상의 연속된 줄바꿈을 단락 구분으로 처리
+            html = html.split(/\n\n+/).map(para => {
+                if (para.trim() && !para.match(/^<[h|u|o|b|p|d]/)) {
+                    // 이미 HTML 태그가 아닌 일반 텍스트만 <p>로 감싸기
+                    if (!para.trim().startsWith('<')) {
+                        return `<p>${para.trim()}</p>`;
+                    }
+                }
+                return para;
+            }).join('\n');
+            
+            // 단일 줄바꿈은 <br>로 (이미 태그로 감싸진 부분은 제외)
+            html = html.replace(/(?<!>)\n(?!<)/g, '<br>');
+            
+            // 빈 <p> 태그 제거
+            html = html.replace(/<p>\s*<\/p>/g, '');
+            html = html.replace(/<p>(<[^>]+>)/g, '$1');
+            html = html.replace(/(<\/[^>]+>)<\/p>/g, '$1');
+            
+            // 나머지 텍스트 이스케이프 (이미 HTML 태그가 아닌 부분만)
+            // 하지만 이미 escapeHtml을 사용한 부분이 있으므로 주의 필요
+            // 기본적으로 마크다운 변환 후 남은 텍스트는 안전하게 처리됨
+            
+            return html;
+        }
+        
         function formatContentWithFootnotes(content) {
             if (!content) return { formattedContent: '', footnotes: [] };
             
-            // 일반 텍스트를 HTML로 변환 (줄바꿈 처리)
-            let htmlContent = escapeHtml(content).replace(/\n/g, '<br>');
+            // 먼저 마크다운을 HTML로 변환
+            let htmlContent = markdownToHtml(content);
             
-            // [근거: 내용] 패턴 찾기
+            // [근거: 내용] 패턴 찾기 (마크다운 변환 후에 처리)
             const footnotePattern = /\[근거:\s*([^\]]+)\]/g;
             const footnotes = [];
             let footnoteIndex = 0;
             
-            // 각 [근거: ] 부분을 찾아서 각주 번호로 치환
-            let formattedContent = htmlContent.replace(footnotePattern, (match, footnoteText) => {
+            // HTML에서 [근거: ] 패턴을 찾아서 각주로 변환
+            htmlContent = htmlContent.replace(footnotePattern, (match, footnoteText) => {
                 footnoteIndex++;
                 const cleanText = footnoteText.trim();
                 footnotes.push(cleanText);
+                // 직접 HTML로 변환 (플레이스홀더 사용하지 않음)
                 return `<sup class="footnote-ref" data-footnote="${footnoteIndex}">[${footnoteIndex}]<span class="footnote-tooltip">${escapeHtml(cleanText)}</span></sup>`;
             });
             
-            return { formattedContent, footnotes };
+            return { formattedContent: htmlContent, footnotes };
         }
         
         // HTML 이스케이프 헬퍼

templates/webnovels.html

@@ -521,6 +521,61 @@
         </div>
     </div>
 
+    <!-- GraphRAG 모달 -->
+    <div id="graphRAGModal" class="modal">
+        <div class="modal-content" style="max-width: 1400px;">
+            <div class="modal-header">
+                <div class="modal-title" id="graphRAGModalTitle">회차별 캐릭터 관계 분석</div>
+                <button class="modal-close" onclick="closeGraphRAGModal()">&times;</button>
+            </div>
+            <div id="graphRAGContent" style="max-height: 80vh; overflow-y: auto; padding: 24px;">
+                <div style="text-align: center; padding: 24px; color: var(--text-secondary);">
+                    GraphRAG 데이터를 불러오는 중...
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- GraphRAG 그래프 시각화 모달 -->
+    <div id="graphRAGVisualizationModal" class="modal">
+        <div class="modal-content" style="max-width: 1600px; width: 95%; height: 90vh;">
+            <div class="modal-header">
+                <div class="modal-title" id="graphRAGVisualizationModalTitle">캐릭터 관계도 시각화</div>
+                <button class="modal-close" onclick="closeGraphRAGVisualizationModal()">&times;</button>
+            </div>
+            <div style="padding: 16px; border-bottom: 1px solid var(--border); background: var(--bg-secondary); display: flex; gap: 12px; align-items: center; flex-wrap: wrap;">
+                <label style="font-size: 14px; font-weight: 500;">회차 필터:</label>
+                <select id="episodeFilter" onchange="updateGraphVisualization()" style="padding: 6px 12px; border: 1px solid var(--border); border-radius: 6px; font-size: 14px; min-width: 200px; background: var(--bg-primary); color: var(--text-primary);">
+                    <option value="all">전체 회차</option>
+                </select>
+                <label style="font-size: 14px; font-weight: 500; margin-left: 16px;">노드 타입:</label>
+                <label style="font-size: 13px; margin-left: 8px;">
+                    <input type="checkbox" id="showCharacters" checked onchange="updateGraphVisualization()" style="margin-right: 4px;">
+                    인물
+                </label>
+                <label style="font-size: 13px; margin-left: 8px;">
+                    <input type="checkbox" id="showLocations" checked onchange="updateGraphVisualization()" style="margin-right: 4px;">
+                    장소
+                </label>
+                <label style="font-size: 13px; margin-left: 8px;">
+                    <input type="checkbox" id="showEvents" checked onchange="updateGraphVisualization()" style="margin-right: 4px;">
+                    사건
+                </label>
+                <button onclick="resetGraphView()" style="padding: 6px 16px; background: var(--accent); color: white; border: none; border-radius: 6px; cursor: pointer; font-size: 13px; margin-left: auto;">
+                    뷰 리셋
+                </button>
+            </div>
+            <div id="graphRAGVisualizationContent" style="height: calc(90vh - 120px); position: relative; background: var(--bg-primary);">
+                <div style="text-align: center; padding: 24px; color: var(--text-secondary); position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);">
+                    그래프를 불러오는 중...
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- vis-network 라이브러리 -->
+    <script type="text/javascript" src="https://unpkg.com/vis-network@latest/standalone/umd/vis-network.min.js"></script>
+
     <!-- 웹소설 내용 보기 모달 -->
     <div id="webnovelContentModal" class="modal">
         <div class="modal-content">
@@ -720,7 +775,9 @@
                     </div>
                     <div class="webnovel-item-actions">
                         <button class="webnovel-item-btn" onclick="viewWebnovelSummary(${file.id}, '${escapeHtml(file.original_filename)}')" style="background: #17a2b8; color: white; margin-right: 8px;">📋 요약 보기</button>
-                        <button class="webnovel-item-btn" onclick="viewWebnovelContent(${file.id}, '${escapeHtml(file.original_filename)}')">📖 내용 보기</button>
+                        <button class="webnovel-item-btn" onclick="viewWebnovelContent(${file.id}, '${escapeHtml(file.original_filename)}')" style="margin-right: 8px;">📖 내용 보기</button>
+                        <button class="webnovel-item-btn" onclick="viewGraphRAG(${file.id}, '${escapeHtml(file.original_filename)}')" style="background: #9c27b0; color: white; margin-right: 8px;">🔗 회차별 캐릭터 관계 분석</button>
+                        <button class="webnovel-item-btn" onclick="viewGraphRAGVisualization(${file.id}, '${escapeHtml(file.original_filename)}')" style="background: #28a745; color: white;">📊 캐릭터 관계도 시각화</button>
                     </div>
                 `;
                 listContainer.appendChild(fileItem);
@@ -1294,6 +1351,529 @@
             }
         });
 
+        document.getElementById('graphRAGModal').addEventListener('click', function(e) {
+            if (e.target === this) {
+                closeGraphRAGModal();
+            }
+        });
+
+        async function viewGraphRAG(fileId, fileName) {
+            const modal = document.getElementById('graphRAGModal');
+            const title = document.getElementById('graphRAGModalTitle');
+            const content = document.getElementById('graphRAGContent');
+            
+            title.textContent = `회차별 캐릭터 관계 분석 - ${fileName}`;
+            content.innerHTML = '<div style="text-align: center; padding: 24px; color: var(--text-secondary);">GraphRAG 데이터를 불러오는 중...</div>';
+            modal.classList.add('active');
+            
+            try {
+                const response = await fetch(`/api/files/${fileId}/graph`, {
+                    credentials: 'include'
+                });
+                if (!response.ok) throw new Error('GraphRAG 데이터를 불러올 수 없습니다.');
+                
+                const data = await response.json();
+                
+                let contentHtml = '';
+                
+                // 통계 정보
+                if (data.statistics) {
+                    contentHtml += '<div style="margin-bottom: 32px; padding: 16px; background: var(--bg-secondary); border-radius: 6px;">';
+                    contentHtml += '<h3 style="font-size: 18px; font-weight: 600; margin-bottom: 16px; color: var(--accent);">통계 정보</h3>';
+                    contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 16px;">';
+                    contentHtml += `<div style="padding: 12px; background: var(--bg-primary); border-radius: 6px;"><strong>엔티티:</strong> ${data.statistics.total_entities}개</div>`;
+                    contentHtml += `<div style="padding: 12px; background: var(--bg-primary); border-radius: 6px;"><strong>관계:</strong> ${data.statistics.total_relationships}개</div>`;
+                    contentHtml += `<div style="padding: 12px; background: var(--bg-primary); border-radius: 6px;"><strong>사건:</strong> ${data.statistics.total_events}개</div>`;
+                    contentHtml += `<div style="padding: 12px; background: var(--bg-primary); border-radius: 6px;"><strong>회차 수:</strong> ${data.statistics.episodes_count}개</div>`;
+                    contentHtml += '</div>';
+                    contentHtml += '</div>';
+                }
+                
+                // 회차별 데이터 표시
+                const episodes = data.episodes || [];
+                
+                if (episodes.length === 0) {
+                    contentHtml += '<div style="text-align: center; padding: 24px; color: var(--text-secondary);">GraphRAG 데이터가 없습니다.</div>';
+                } else {
+                    episodes.forEach(episode => {
+                        contentHtml += `<div style="margin-bottom: 32px; padding: 20px; background: var(--bg-secondary); border-radius: 8px; border-left: 4px solid var(--accent);">`;
+                        contentHtml += `<h3 style="font-size: 20px; font-weight: 600; margin-bottom: 20px; color: var(--accent);">${escapeHtml(episode)}</h3>`;
+                        
+                        // 엔티티 (인물)
+                        const characters = data.entities_by_episode[episode]?.characters || [];
+                        if (characters.length > 0) {
+                            contentHtml += '<div style="margin-bottom: 20px;">';
+                            contentHtml += '<h4 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; color: #1967d2;">인물</h4>';
+                            contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 12px;">';
+                            characters.forEach(char => {
+                                contentHtml += '<div style="padding: 12px; background: var(--bg-primary); border-radius: 6px; border: 1px solid var(--border);">';
+                                contentHtml += `<div style="font-weight: 600; margin-bottom: 8px; color: var(--accent);">${escapeHtml(char.entity_name)}</div>`;
+                                if (char.role) {
+                                    contentHtml += `<div style="font-size: 13px; color: var(--text-secondary); margin-bottom: 4px;"><strong>역할:</strong> ${escapeHtml(char.role)}</div>`;
+                                }
+                                if (char.description) {
+                                    contentHtml += `<div style="font-size: 13px; color: var(--text-secondary);">${escapeHtml(char.description)}</div>`;
+                                }
+                                contentHtml += '</div>';
+                            });
+                            contentHtml += '</div>';
+                            contentHtml += '</div>';
+                        }
+                        
+                        // 엔티티 (장소)
+                        const locations = data.entities_by_episode[episode]?.locations || [];
+                        if (locations.length > 0) {
+                            contentHtml += '<div style="margin-bottom: 20px;">';
+                            contentHtml += '<h4 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; color: #1967d2;">장소</h4>';
+                            contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 12px;">';
+                            locations.forEach(loc => {
+                                contentHtml += '<div style="padding: 12px; background: var(--bg-primary); border-radius: 6px; border: 1px solid var(--border);">';
+                                contentHtml += `<div style="font-weight: 600; margin-bottom: 8px; color: var(--accent);">${escapeHtml(loc.entity_name)}</div>`;
+                                if (loc.category) {
+                                    contentHtml += `<div style="font-size: 13px; color: var(--text-secondary); margin-bottom: 4px;"><strong>유형:</strong> ${escapeHtml(loc.category)}</div>`;
+                                }
+                                if (loc.description) {
+                                    contentHtml += `<div style="font-size: 13px; color: var(--text-secondary);">${escapeHtml(loc.description)}</div>`;
+                                }
+                                contentHtml += '</div>';
+                            });
+                            contentHtml += '</div>';
+                            contentHtml += '</div>';
+                        }
+                        
+                        // 관계
+                        const relationships = data.relationships_by_episode[episode] || [];
+                        if (relationships.length > 0) {
+                            contentHtml += '<div style="margin-bottom: 20px;">';
+                            contentHtml += '<h4 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; color: #1967d2;">관계</h4>';
+                            contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(400px, 1fr)); gap: 12px;">';
+                            relationships.forEach(rel => {
+                                contentHtml += '<div style="padding: 12px; background: var(--bg-primary); border-radius: 6px; border: 1px solid var(--border);">';
+                                contentHtml += `<div style="margin-bottom: 8px;">`;
+                                contentHtml += `<span style="font-weight: 600; color: var(--accent);">${escapeHtml(rel.source)}</span>`;
+                                contentHtml += `<span style="margin: 0 8px; color: var(--text-secondary);">→</span>`;
+                                contentHtml += `<span style="font-weight: 600; color: var(--accent);">${escapeHtml(rel.target)}</span>`;
+                                contentHtml += '</div>';
+                                if (rel.relationship_type) {
+                                    contentHtml += `<div style="font-size: 13px; color: var(--text-secondary); margin-bottom: 4px;"><strong>관계 유형:</strong> ${escapeHtml(rel.relationship_type)}</div>`;
+                                }
+                                if (rel.description) {
+                                    contentHtml += `<div style="font-size: 13px; color: var(--text-secondary); margin-bottom: 4px;">${escapeHtml(rel.description)}</div>`;
+                                }
+                                if (rel.event) {
+                                    contentHtml += `<div style="font-size: 12px; color: #856404; padding: 8px; background: #fff3cd; border-radius: 4px; margin-top: 8px;"><strong>관련 사건:</strong> ${escapeHtml(rel.event)}</div>`;
+                                }
+                                contentHtml += '</div>';
+                            });
+                            contentHtml += '</div>';
+                            contentHtml += '</div>';
+                        }
+                        
+                        // 사건
+                        const events = data.events_by_episode[episode] || [];
+                        if (events.length > 0) {
+                            contentHtml += '<div style="margin-bottom: 20px;">';
+                            contentHtml += '<h4 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; color: #1967d2;">사건</h4>';
+                            contentHtml += '<div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(400px, 1fr)); gap: 12px;">';
+                            events.forEach(event => {
+                                contentHtml += '<div style="padding: 12px; background: var(--bg-primary); border-radius: 6px; border: 1px solid var(--border);">';
+                                if (event.event_name) {
+                                    contentHtml += `<div style="font-weight: 600; margin-bottom: 8px; color: var(--accent);">${escapeHtml(event.event_name)}</div>`;
+                                }
+                                if (event.description) {
+                                    contentHtml += `<div style="font-size: 13px; color: var(--text-secondary); margin-bottom: 8px; line-height: 1.6;">${escapeHtml(event.description)}</div>`;
+                                }
+                                if (event.participants && event.participants.length > 0) {
+                                    contentHtml += `<div style="font-size: 13px; color: var(--text-secondary); margin-bottom: 4px;"><strong>관련 인물:</strong> ${escapeHtml(event.participants.join(', '))}</div>`;
+                                }
+                                if (event.location) {
+                                    contentHtml += `<div style="font-size: 13px; color: var(--text-secondary); margin-bottom: 4px;"><strong>장소:</strong> ${escapeHtml(event.location)}</div>`;
+                                }
+                                if (event.significance) {
+                                    contentHtml += `<div style="font-size: 12px; color: #137333; padding: 6px; background: #e8f5e9; border-radius: 4px; margin-top: 8px; display: inline-block;"><strong>중요도:</strong> ${escapeHtml(event.significance)}</div>`;
+                                }
+                                contentHtml += '</div>';
+                            });
+                            contentHtml += '</div>';
+                            contentHtml += '</div>';
+                        }
+                        
+                        contentHtml += '</div>';
+                    });
+                }
+                
+                content.innerHTML = contentHtml;
+            } catch (error) {
+                console.error('GraphRAG 데이터 로드 오류:', error);
+                content.innerHTML = '<div style="text-align: center; padding: 24px; color: #ea4335;">GraphRAG 데이터를 불러오는 중 오류가 발생했습니다.</div>';
+            }
+        }
+
+        function closeGraphRAGModal() {
+            document.getElementById('graphRAGModal').classList.remove('active');
+        }
+
+        // GraphRAG 그래프 시각화 관련 변수
+        let webnovelGraphData = null;
+        let webnovelGraphNetwork = null;
+        let webnovelAllGraphData = null;
+
+        async function viewGraphRAGVisualization(fileId, fileName) {
+            const modal = document.getElementById('graphRAGVisualizationModal');
+            const title = document.getElementById('graphRAGVisualizationModalTitle');
+            const content = document.getElementById('graphRAGVisualizationContent');
+            
+            title.textContent = `캐릭터 관계도 시각화 - ${fileName}`;
+            content.innerHTML = '<div style="text-align: center; padding: 24px; color: var(--text-secondary); position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);">그래프를 불러오는 중...</div>';
+            modal.classList.add('active');
+            
+            // 기존 네트워크 제거
+            if (webnovelGraphNetwork) {
+                webnovelGraphNetwork.destroy();
+                webnovelGraphNetwork = null;
+            }
+            
+            try {
+                const response = await fetch(`/api/files/${fileId}/graph`, {
+                    credentials: 'include'
+                });
+                if (!response.ok) throw new Error('GraphRAG 데이터를 불러올 수 없습니다.');
+                
+                const data = await response.json();
+                webnovelAllGraphData = data;
+                
+                // 회차 필터 옵션 생성
+                const episodeFilter = document.getElementById('episodeFilter');
+                episodeFilter.innerHTML = '<option value="all">전체 회차</option>';
+                if (data.episodes && data.episodes.length > 0) {
+                    data.episodes.forEach(episode => {
+                        const option = document.createElement('option');
+                        option.value = episode;
+                        option.textContent = episode;
+                        episodeFilter.appendChild(option);
+                    });
+                }
+                
+                // 그래프 생성
+                createWebnovelGraphVisualization(data);
+            } catch (error) {
+                console.error('GraphRAG 그래프 로드 오류:', error);
+                content.innerHTML = '<div style="text-align: center; padding: 24px; color: #ea4335; position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);">그래프를 불러오는 중 오류가 발생했습니다.</div>';
+            }
+        }
+
+        function createWebnovelGraphVisualization(data, episodeFilter = 'all') {
+            const content = document.getElementById('graphRAGVisualizationContent');
+            content.innerHTML = ''; // 기존 내용 제거
+            
+            // 노드와 엣지 데이터 생성
+            const nodes = new vis.DataSet([]);
+            const edges = new vis.DataSet([]);
+            
+            const nodeMap = new Map(); // 노드 ID 매핑
+            let nodeIdCounter = 1;
+            
+            const showCharacters = document.getElementById('showCharacters').checked;
+            const showLocations = document.getElementById('showLocations').checked;
+            const showEvents = document.getElementById('showEvents').checked;
+            
+            // 필터링할 회차 목록
+            const episodes = episodeFilter === 'all' 
+                ? (data.episodes || [])
+                : [episodeFilter];
+            
+            // 엔티티 추가 (인물, 장소)
+            episodes.forEach(episode => {
+                const entities = data.entities_by_episode?.[episode] || {};
+                
+                // 인물 추가
+                if (showCharacters && entities.characters) {
+                    entities.characters.forEach(char => {
+                        const nodeId = `char_${char.entity_name}`;
+                        if (!nodeMap.has(nodeId)) {
+                            const id = nodeIdCounter++;
+                            nodeMap.set(nodeId, id);
+                            nodes.add({
+                                id: id,
+                                label: char.entity_name,
+                                title: `인물: ${char.entity_name}\n역할: ${char.role || '없음'}\n설명: ${char.description || '없음'}`,
+                                color: {
+                                    background: '#4285f4',
+                                    border: '#1967d2',
+                                    highlight: { background: '#1a73e8', border: '#1557b0' }
+                                },
+                                shape: 'ellipse',
+                                font: { size: 14, face: 'Inter' },
+                                size: 20
+                            });
+                        }
+                    });
+                }
+                
+                // 장소 추가
+                if (showLocations && entities.locations) {
+                    entities.locations.forEach(loc => {
+                        const nodeId = `loc_${loc.entity_name}`;
+                        if (!nodeMap.has(nodeId)) {
+                            const id = nodeIdCounter++;
+                            nodeMap.set(nodeId, id);
+                            nodes.add({
+                                id: id,
+                                label: loc.entity_name,
+                                title: `장소: ${loc.entity_name}\n유형: ${loc.category || '없음'}\n설명: ${loc.description || '없음'}`,
+                                color: {
+                                    background: '#34a853',
+                                    border: '#137333',
+                                    highlight: { background: '#2e7d32', border: '#1b5e20' }
+                                },
+                                shape: 'box',
+                                font: { size: 14, face: 'Inter' },
+                                size: 20
+                            });
+                        }
+                    });
+                }
+            });
+            
+            // 사건 추가
+            if (showEvents) {
+                episodes.forEach(episode => {
+                    const events = data.events_by_episode?.[episode] || [];
+                    events.forEach(event => {
+                        const eventName = event.event_name || `사건_${episode}_${events.indexOf(event)}`;
+                        const nodeId = `event_${eventName}`;
+                        if (!nodeMap.has(nodeId)) {
+                            const id = nodeIdCounter++;
+                            nodeMap.set(nodeId, id);
+                            nodes.add({
+                                id: id,
+                                label: eventName,
+                                title: `사건: ${eventName}\n설명: ${event.description || '없음'}\n관련 인물: ${event.participants ? event.participants.join(', ') : '없음'}\n장소: ${event.location || '없음'}\n중요도: ${event.significance || '없음'}`,
+                                color: {
+                                    background: '#ff9800',
+                                    border: '#f57c00',
+                                    highlight: { background: '#fb8c00', border: '#e65100' }
+                                },
+                                shape: 'diamond',
+                                font: { size: 13, face: 'Inter' },
+                                size: 25
+                            });
+                            
+                            // 사건과 관련 인물 연결
+                            if (event.participants && Array.isArray(event.participants)) {
+                                event.participants.forEach(participant => {
+                                    const participantNodeId = `char_${participant}`;
+                                    const participantId = nodeMap.get(participantNodeId);
+                                    if (participantId) {
+                                        edges.add({
+                                            from: participantId,
+                                            to: id,
+                                            label: '참여',
+                                            title: `${participant}이(가) ${eventName}에 참여`,
+                                            color: {
+                                                color: '#ff9800',
+                                                highlight: '#f57c00'
+                                            },
+                                            arrows: 'to',
+                                            font: { size: 11, align: 'middle' },
+                                            dashes: true,
+                                            smooth: {
+                                                type: 'curvedCW',
+                                                roundness: 0.3
+                                            }
+                                        });
+                                    }
+                                });
+                            }
+                            
+                            // 사건과 장소 연결
+                            if (event.location) {
+                                const locationNodeId = `loc_${event.location}`;
+                                const locationId = nodeMap.get(locationNodeId);
+                                if (locationId) {
+                                    edges.add({
+                                        from: locationId,
+                                        to: id,
+                                        label: '발생',
+                                        title: `${eventName}이(가) ${event.location}에서 발생`,
+                                        color: {
+                                            color: '#ff9800',
+                                            highlight: '#f57c00'
+                                        },
+                                        arrows: 'to',
+                                        font: { size: 11, align: 'middle' },
+                                        dashes: [5, 5],
+                                        smooth: {
+                                            type: 'curvedCW',
+                                            roundness: 0.3
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                    });
+                });
+            }
+            
+            // 관계 추가
+            episodes.forEach(episode => {
+                const relationships = data.relationships_by_episode?.[episode] || [];
+                relationships.forEach(rel => {
+                    // 소스와 타겟이 인물인지 장소인지 확인
+                    let sourceNodeId = null;
+                    let targetNodeId = null;
+                    
+                    // 소스 노드 찾기
+                    if (nodeMap.has(`char_${rel.source}`)) {
+                        sourceNodeId = nodeMap.get(`char_${rel.source}`);
+                    } else if (nodeMap.has(`loc_${rel.source}`)) {
+                        sourceNodeId = nodeMap.get(`loc_${rel.source}`);
+                    }
+                    
+                    // 타겟 노드 찾기
+                    if (nodeMap.has(`char_${rel.target}`)) {
+                        targetNodeId = nodeMap.get(`char_${rel.target}`);
+                    } else if (nodeMap.has(`loc_${rel.target}`)) {
+                        targetNodeId = nodeMap.get(`loc_${rel.target}`);
+                    }
+                    
+                    if (sourceNodeId && targetNodeId) {
+                        edges.add({
+                            from: sourceNodeId,
+                            to: targetNodeId,
+                            label: rel.relationship_type || '',
+                            title: `관계: ${rel.relationship_type || '없음'}\n설명: ${rel.description || '없음'}${rel.event ? `\n관련 사건: ${rel.event}` : ''}`,
+                            color: {
+                                color: '#ea4335',
+                                highlight: '#c5221f'
+                            },
+                            arrows: 'to',
+                            font: { size: 12, align: 'middle' },
+                            smooth: {
+                                type: 'curvedCW',
+                                roundness: 0.2
+                            }
+                        });
+                    }
+                });
+            });
+            
+            // 네트워크 생성
+            const container = document.createElement('div');
+            container.id = 'webnovelGraphNetworkContainer';
+            container.style.width = '100%';
+            container.style.height = '100%';
+            content.appendChild(container);
+            
+            const graphData = {
+                nodes: nodes,
+                edges: edges
+            };
+            
+            const options = {
+                nodes: {
+                    borderWidth: 2,
+                    shadow: true,
+                    font: {
+                        size: 14,
+                        face: 'Inter'
+                    }
+                },
+                edges: {
+                    width: 2,
+                    shadow: true,
+                    font: {
+                        size: 12,
+                        align: 'middle'
+                    },
+                    arrows: {
+                        to: {
+                            enabled: true,
+                            scaleFactor: 0.8
+                        }
+                    }
+                },
+                physics: {
+                    enabled: true,
+                    stabilization: {
+                        enabled: true,
+                        iterations: 200
+                    },
+                    barnesHut: {
+                        gravitationalConstant: -2000,
+                        centralGravity: 0.1,
+                        springLength: 200,
+                        springConstant: 0.04,
+                        damping: 0.09
+                    }
+                },
+                interaction: {
+                    hover: true,
+                    tooltipDelay: 200,
+                    zoomView: true,
+                    dragView: true
+                },
+                layout: {
+                    improvedLayout: true
+                }
+            };
+            
+            webnovelGraphNetwork = new vis.Network(container, graphData, options);
+            
+            // 네트워크 이벤트 리스너
+            webnovelGraphNetwork.on('click', function(params) {
+                if (params.nodes.length > 0) {
+                    const nodeId = params.nodes[0];
+                    const node = nodes.get(nodeId);
+                    if (node) {
+                        console.log('선택된 노드:', node);
+                    }
+                }
+            });
+        }
+
+        function updateGraphVisualization() {
+            if (!webnovelAllGraphData) return;
+            
+            const episodeFilter = document.getElementById('episodeFilter').value;
+            
+            // 기존 네트워크 제거
+            if (webnovelGraphNetwork) {
+                webnovelGraphNetwork.destroy();
+                webnovelGraphNetwork = null;
+            }
+            
+            // 새 그래프 생성
+            createWebnovelGraphVisualization(webnovelAllGraphData, episodeFilter);
+        }
+
+        function resetGraphView() {
+            if (webnovelGraphNetwork) {
+                webnovelGraphNetwork.fit({
+                    animation: {
+                        duration: 1000,
+                        easingFunction: 'easeInOutQuad'
+                    }
+                });
+            }
+        }
+
+        function closeGraphRAGVisualizationModal() {
+            document.getElementById('graphRAGVisualizationModal').classList.remove('active');
+            if (webnovelGraphNetwork) {
+                webnovelGraphNetwork.destroy();
+                webnovelGraphNetwork = null;
+            }
+            webnovelGraphData = null;
+            webnovelAllGraphData = null;
+        }
+
+        document.getElementById('graphRAGVisualizationModal').addEventListener('click', function(e) {
+            if (e.target === this) {
+                closeGraphRAGVisualizationModal();
+            }
+        });
+
         // 페이지 로드 시 초기화
         window.addEventListener('load', async () => {
             await loadWebnovelModelFilter();