Initial commit for HF Spaces deployment

.devcontainer/devcontainer.json

@@ -0,0 +1,33 @@
+{
+  "name": "Python 3",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bookworm",
+  "customizations": {
+    "codespaces": {
+      "openFiles": [
+        "README.md",
+        "src/visualization/streamlit_app.py"
+      ]
+    },
+    "vscode": {
+      "settings": {},
+      "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance"
+      ]
+    }
+  },
+  "updateContentCommand": "[ -f packages.txt ] && sudo apt update && sudo apt upgrade -y && sudo xargs apt install -y <packages.txt; [ -f requirements.txt ] && pip3 install --user -r requirements.txt; pip3 install --user streamlit; echo '✅ Packages installed and Requirements met'",
+  "postAttachCommand": {
+    "server": "streamlit run src/visualization/streamlit_app.py --server.enableCORS false --server.enableXsrfProtection false"
+  },
+  "portsAttributes": {
+    "8501": {
+      "label": "Application",
+      "onAutoForward": "openPreview"
+    }
+  },
+  "forwardPorts": [
+    8501
+  ]
+}

.dockerfile

@@ -0,0 +1,68 @@
+# ===== GPU 지원 Dockerfile for Hugging Face Spaces =====
+# CUDA 지원 Python 베이스 이미지
+FROM nvidia/cuda:12.1.0-devel-ubuntu22.04
+
+# ===== Python 3.12.3 설치 =====
+# deadsnakes PPA를 통해 Python 3.12 설치
+RUN apt-get update && apt-get install -y \
+    software-properties-common \
+    && add-apt-repository ppa:deadsnakes/ppa \
+    && apt-get update
+
+# Python 3.12 및 필수 패키지 설치
+RUN apt-get install -y \
+    python3.12 \
+    python3.12-dev \
+    python3.12-distutils \
+    python3.12-venv \
+    build-essential \
+    cmake \
+    git \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python 3.12를 기본 python으로 설정
+RUN update-alternatives --install /usr/bin/python python /usr/bin/python3.12 1 \
+    && update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.12 1
+
+# pip 설치 (Python 3.12용)
+RUN curl -sS https://bootstrap.pypa.io/get-pip.py | python3.12
+RUN python -m pip install --upgrade pip setuptools wheel
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# 의존성 파일 복사
+COPY requirements.txt .
+
+# ===== llama-cpp-python CUDA 빌드 =====
+# CUDA 지원으로 llama-cpp-python 설치 (먼저 설치)
+ENV CMAKE_ARGS="-DLLAMA_CUBLAS=on"
+ENV FORCE_CMAKE=1
+RUN pip install --no-cache-dir llama-cpp-python==0.3.16
+
+# ===== 나머지 의존성 설치 =====
+# llama-cpp-python 제외하고 설치
+RUN pip install --no-cache-dir -r requirements.txt
+
+# ===== 프로젝트 파일 복사 =====
+COPY . .
+
+# ===== 환경변수 설정 =====
+# CUDA 가시성 (GPU 사용)
+ENV CUDA_VISIBLE_DEVICES=0
+
+# ===== Streamlit 설정 =====
+# HF Spaces는 포트 7860 사용
+EXPOSE 7860
+
+# ===== 헬스체크 (선택) =====
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/_stcore/health || exit 1
+
+# ===== 실행 명령 =====
+CMD ["streamlit", "run", "src/visualization/chatbot_app.py", \
+     "--server.port=7860", \
+     "--server.address=0.0.0.0", \
+     "--server.headless=true", \
+     "--server.fileWatcherType=none"]

.env.example

@@ -0,0 +1,15 @@
+OPENAI_API_KEY = "OPENAI_API_KEY"
+
+# Wandb 설정(선택)
+WANDB_API_KEY = "WANDB_API_KEY"
+
+# LangSmith 설정(선택)
+LANGCHAIN_TRACING_V2=true
+LANGSMITH_API_KEY = "LANGSMITH_API_KEY"
+LANGCHAIN_PROJECT = "LANGCHAIN_PROJECT"
+
+# 로컬 개발 (로컬 파일 사용)
+# USE_MODEL_HUB=false
+
+# Hugging Face Spaces 배포 (Model Hub 사용)
+USE_MODEL_HUB=true

.gitattributes

@@ -0,0 +1,8 @@
+# Git LFS로 추적할 대용량 파일
+chroma_db/** filter=lfs diff=lfs merge=lfs -text
+data/rag_chunks_final.csv filter=lfs diff=lfs merge=lfs -text
+
+# 바이너리 파일 명시
+*.db filter=lfs diff=lfs merge=lfs -text
+*.sqlite filter=lfs diff=lfs merge=lfs -text
+*.sqlite3 filter=lfs diff=lfs merge=lfs -text

.gitignore

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

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:system",
+    "python-envs.pythonProjects": []
+}

EDA_report.md

@@ -0,0 +1,614 @@
+# 문서 요약 챗봇 프로젝트 EDA 보고서
+
+**작성일**: 2024년 11월 11일 
+**분석자**: 1팀(이유노, 김진욱, 박지윤, 지동진)
+
+---
+
+## 📋 목차
+1. [데이터 개요](#1-데이터-개요)
+2. [기본 통계 분석](#2-기본-통계-분석)
+3. [파일 형식별 비교](#3-파일-형식별-비교)
+4. [문장 구조 분석](#4-문장-구조-분석)
+5. [품질 이슈 및 이상치](#5-품질-이슈-및-이상치)
+6. [주요 인사이트 및 활용 방안](#6-주요-인사이트-및-활용-방안)
+
+---
+
+## 1. 데이터 개요
+
+### 1.1 데이터셋 구성
+- **총 파일 수**: 100개
+- **PDF 파일**: 4개 (4%)
+- **HWP 파일**: 96개 (96%)
+
+### 1.2 데이터 출처
+- 공공기관의 정보시스템 구축 사업 제안요청서
+- 주요 발주기관: 대학교, 지방자치단체, 공공기관 등
+
+### 1.3 데이터 구조
+```
+1팀 중급 프로젝트/
+├── data/
+│   ├── data_list.xlsx
+│   ├── data_list.csv
+│   └── files/
+│       ├── 문서1.hwp
+│       ├── 문서2.pdf
+│       └── ...
+```
+
+> **💡 활용 방안**  
+> 데이터 불균형(96:4)으로 인해 HWP 파일만 사용하는 전략 고려. PDF는 추가 수집 또는 제외 검토 필요.
+
+---
+
+## 2. 기본 통계 분석
+
+### 2.1 문자 수 통계
+
+| 통계량 | 값 |
+|--------|-----|
+| 평균 | 3,835자 |
+| 중앙값 | 2,583자 |
+| 최소값 | 80자 |
+| 최대값 | 18,328자 |
+| 표준편차 | 3,692자 |
+| 1사분위수 (25%) | 1,188자 |
+| 3사분위수 (75%) | 5,827자 |
+
+**분포 특성**:
+- 대부분의 문서가 1,000~6,000자 범위에 분포
+- 소수의 긴 문서(10,000자 이상) 존재
+- 극단적으로 짧은 문서(500자 미만) 약 25% 존재
+
+> **💡 활용 방안**  
+> - **RAG 시스템**: 평균 문서 길이(3,835자 ≈ 2,000 토큰)를 고려하여 청크 크기 512 토큰, 문서당 4-5개 청크 예상
+> - **Fine-tuning**: 극단적으로 짧거나 긴 문서는 품질 필터링 대상
+> - **API 모델**: 평균 길이 기준으로 프롬프트 최적화 및 비용 산정
+
+### 2.2 문장 수 통계
+
+| 통계량 | 값 |
+|--------|-----|
+| 평균 | 215.5문장 |
+| 중앙값 | 161.5문장 |
+| 최소값 | 5문장 |
+| 최대값 | 1,107문장 |
+| 표준편차 | 201.2문장 |
+| 1사분위수 (25%) | 76.5문장 |
+| 3사분위수 (75%) | 295.8문장 |
+
+**분포 특성**:
+- 중앙값(161.5)이 평균(215.5)보다 낮음 → 우편향 분포
+- 소수의 매우 긴 문서가 평균을 끌어올림
+- 대부분 100-300문장 범위에 분포
+
+> **💡 활용 방안**  
+> - **청크 분할**: 문장 단위 청크 분할 시 기준 설정 (예: 10-15문장당 1개 청크)
+> - **품질 필터링**: 5문장 미만 문서는 내용이 부족할 가능성 → 제외 고려
+> - **배치 처리**: 문장 수 기준으로 배치 크기 조정 가능
+
+### 2.3 문장 길이 통계
+
+| 통계량 | 평균 문장 길이 | 최대 문장 길이 |
+|--------|--------------|--------------|
+| 평균 | 16.3자 | 104.5자 |
+| 중앙값 | 15.8자 | 106.5자 |
+| 최소값 | 7.3자 | 13자 |
+| 최대값 | 52.6자 | 259자 |
+| 표준편차 | 5.6자 | 51.3자 |
+
+**한국어 문장 특성**:
+- 평균 문장 길이 16.3자는 한국어로서 적절한 범위 (일반적으로 15-20자)
+- 최대 문장 길이의 편차가 큼 (표준편차 51.3자) → 일부 비정상적인 긴 문장 존재
+
+> **💡 활용 방안**  
+> - **이상치 탐지**: 평균 문장 길이 > 30자인 파일은 문장 분할 실패 가능성 → 재검토 필요
+> - **전처리 전략**: 최대 문장 길이 > 150자인 경우 추가 분할 로직 적용
+> - **품질 평가**: 정상적인 문장 길이 분포는 양질의 데이터 지표
+
+---
+
+## 3. 파일 형식별 비교
+
+### 3.1 형식별 주요 지표
+
+| 지표 | HWP (96개) | PDF (4개) | 차이 | 비고 |
+|------|-----------|----------|------|------|
+| 평균 문자 수 | 3,930자 | 1,548자 | HWP가 2.5배 많음 | ⚠️ PDF가 짧음 |
+| 평균 문장 수 | 221문장 | 63문장 | HWP가 3.5배 많음 | ⚠️ PDF가 적음 |
+| 평균 문장 길이 | **15.9자** | **26.8자** | PDF가 69% 더 김 | 🚨 비정상 |
+| 최대 문장 길이 | 105자 | 84자 | 비슷 | ✅ 정상 |
+
+### 3.2 시각적 비교
+
+**파일 형식 분포**:
+```
+HWP: ████████████████████████████████████████████ 96개 (96%)
+PDF: ██ 4개 (4%)
+```
+
+**문장 길이 박스플롯 해석**:
+- HWP: 중앙값 약 16자, IQR(사분위 범위) 좁음 → 일관된 품질
+- PDF: 중앙값 약 27자, 편차 큼 → 불안정한 품질
+
+### 3.3 핵심 발견사항
+
+#### 🚨 PDF 문장 길이 이상
+- PDF의 평균 문장 길이(26.8자)가 HWP(15.9자)보다 **69% 더 김**
+- 정상적인 한국어 문장 평균(15-20자)을 크게 벗어남
+
+**추정 원인**:
+1. 문장 분할 실패 (줄바꿈이 문장 구분으로 인식되지 않음)
+2. 표나 목차가 한 문장으��� 추출됨
+3. PDF 내부 구조 문제 (이미지 기반 PDF일 가능성)
+
+#### ✅ HWP 추출 품질 우수
+- 평균 문장 길이 15.9자 → 한국어 자연어로서 적절
+- 96개 중 95개가 정상 범위 → 추출 성공률 98.9%
+
+> **💡 활용 방안**  
+> - **PDF 처리 전략**: 
+>   1. 다른 추출 라이브러리 시도 (pdfplumber, PyMuPDF)
+>   2. OCR 적용 (이미지 기반 PDF 대응) - 시간 관계상 제외
+>   3. 개선 실패 시 학습 데이터에서 제외
+> - **HWP 중심 전략**: 추출 품질이 우수한 HWP 96개만으로 프로젝트 진행 가능
+> - **데이터 균형**: PDF 추가 수집 또는 무시 결정 필요
+
+---
+
+## 4. 문장 구조 분석
+
+### 4.1 평균 문장 길이 분포
+
+**분포 특성**:
+- **최빈 구간**: 15-20자
+- **분포 형태**: 정규분포에 가까움
+- **중앙값**: 15.8자
+- **이상치**: 50자 이상인 경우 소수 존재 (약 1%)
+
+**히스토그램 해석**:
+```
+ 7-10자:  ▓▓▓▓▓░░░░░ (약 10개)
+11-15자:  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░ (약 30개)
+16-20자:  ▓▓▓▓▓▓▓▓▓▓▓░░░░░░░ (약 25개)
+21-25자:  ▓▓▓▓▓░░░░░ (약 15개)
+26-30자:  ▓▓░░░░░░░░ (약 8개)
+31자 이상: ▓░░░░░░░░░ (약 5개)
+```
+
+> **💡 활용 방안**  
+> - **품질 필터링**: 평균 문장 길이 > 30자인 파일은 문장 분할 로직 재검토 필요
+> - **프롬프트 설계**: 대부분 15-20자 문장 → 간결한 응답 스타일 학습 가능
+> - **모델 평가**: 생성된 요약문의 문장 길이도 15-20자 범위 유지 시 자연스러움
+
+### 4.2 최대 문장 길이 분포
+
+**분포 특성**:
+- **중앙값**: 약 107자
+- **분포**: 우편향 (대부분 100자 이하)
+- **이상치**: 250자 이상 2개 (상위 1%)
+
+**구간별 분포**:
+```
+  0-50자:   ▓░░░░░░░░░ (약 7개)
+ 51-100자:  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░ (약 40개)
+101-150자:  ▓▓▓▓▓▓▓▓▓▓▓░░░░░░ (약 30개)
+151-200자:  ▓▓▓░░░░░░░ (약 12개)
+201-250자:  ▓░░░░░░░░░ (약 4개)
+250자 이상: ▓░░░░░░░░░ (약 2개)
+```
+
+**이상치 파일**:
+1. 인천광역시_도시계획위원회 통합관리시스템 구축용역.hwp (259자)
+2. 고려대학교_차세대 포털·학사 정보시스템 구축사업.pdf (176자)
+
+> **💡 활용 방안**  
+> - **추가 분할 필요**: 최대 문장 길이 > 150자인 경우 추가 문장 분할 로직 적용
+> - **Fine-tuning**: 비정상적으로 긴 문장은 학습 데이터 품질 저하 원인 → 필터링 고려
+> - **RAG 청크 분할**: 긴 문장도 포함할 수 있도록 청크 크기 여유 있게 설정
+
+### 4.3 특수문자 및 구두점 비율
+
+#### 구두점 비율
+
+| 통계량 | 값 |
+|--------|-----|
+| 평균 | 6.5% |
+| 중앙값 | 5.6% |
+| 최소값 | 1.0% |
+| 최대값 | 67.8% |
+| 표준편차 | 7.0% |
+
+**분포 특성**:
+- 대부분의 문서: 0-10% 범위에 집중
+- 정상 범위로 판단 (한국어 문서 일반적으로 5-10%)
+- 극단 이상치 1개 (67.8%) → 문제 파일
+
+#### 특수문자 비율
+
+| 통계량 | 값 |
+|--------|-----|
+| 평균 | 2.0% |
+| 중앙값 | 0.5% |
+| 최소값 | 0.0% |
+| 최대값 | 73.1% |
+| 표준편차 | 9.7% |
+
+**분포 특성**:
+- 대부분의 문서: 0-5% 범위에 극도로 집중
+- 매우 낮은 특수문자 비율 → 깨끗한 텍스트
+- 극단 이상치 1개 (73.1%) → 심각한 추출 오류
+
+**히스토그램 해석**:
+```
+특수문자 비율:
+ 0-5%:   ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ (약 95개) ← 정상
+ 5-10%:  ▓░░░░░░░░░ (약 3개)
+10-15%:  ░░░░░░░░░░ (0개)
+15%+:    ▓░░░░░░░░░ (약 2개) ← 이상
+
+구두점 비율:
+ 0-10%:  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░ (약 90개) ← 정상
+10-20%:  ▓▓░░░░░░░░ (약 8개)
+20%+:    ▓░░░░░░░░░ (약 2개) ← 이상
+```
+
+> **💡 활용 방안**  
+> - **품질 필터링 기준**: 
+>   - 특수문자 비율 > 15% → 추출 실패로 간주, 제외
+>   - 구두점 비율 > 20% → 비정상 문서, 검토 필요
+> - **전처리 전략**: 대부분 특수문자가 적어 전처리 부담이 적음
+> - **모델 학습**: 깨끗한 텍스트 → 고품질 학습 데이터
+
+---
+
+## 5. 품질 이슈 및 이상치
+
+### 5.1 이상치 탐지 결과
+
+**전체 요약**:
+- **긴 문장 이상치**: 1개 (1.0%)
+- **특수문자 과다**: 1개 (1.0%)
+- **총 문제 파일**: 2개 (2.0%)
+- **정상 파일**: 98개 (98.0%)
+
+### 5.2 심각한 문제 파일 (학습 데이터 제외 필수)
+
+#### 🚨 파일 #1: 고려대학교 PDF
+
+**파일명**: `고려대학교_차세대 포털·학사 정보시스템 구축사업.pdf`
+
+| 지표 | 값 | 정상 범위 | 평가 | 심각도 |
+|------|-----|----------|------|--------|
+| 평균 문장 길이 | 52.6자 | 15-20자 | ❌ 정상의 3배 | 🚨 심각 |
+| 특수문자 비율 | 73.1% | 0-5% | ❌ 14배 초과 | 🚨 심각 |
+| 문장 수 | 42개 | 100+ | ❌ 비정상적으로 적음 | 🚨 심각 |
+| 문자 수 | 2,450자 | 3,000+ | ⚠️ 짧음 | ⚠️ 주의 |
+
+**문제 진단**:
+- 텍스트 추출 완전 실패
+- 표/목차/특수기호만 추출된 것으로 추정
+- 실제 본문 내용이 거의 포함되지 않음
+
+**예상 원인**:
+1. 이미지 기반 PDF (스캔 문서)
+2. 복잡한 PDF 레이아웃 (다단 구성, 표 중심)
+3. PDF 암호화 또는 보안 설정
+
+**조치 방안**:
+- ❌ **학습 데이터에서 완전 제외 (필수)**
+- 재추출 시도 불필요 (품질 회복 불가능 판단)
+- 대체 데이터 확보 고려
+
+---
+
+### 5.3 경미한 문제 파일 (수동 검토 필요)
+
+#### ⚠️ 파일 #2: 인천광역시 HWP
+
+**파일명**: `인천광역시_도시계획위원회 통합관리시스템 구축용역.hwp`
+
+| 지표 | 값 | 정상 범위 | 평가 | 심각도 |
+|------|-----|----------|------|--------|
+| 최대 문장 길이 | 259자 | 100자 이하 | ⚠️ 상위 1% | ⚠️ 주의 |
+| 평균 문장 길이 | 22.1자 | 15-20자 | ✅ 약간 높지만 양호 | ✅ 정상 |
+| 특수문자 비율 | 0.5% | 0-5% | ✅ 정상 | ✅ 정상 |
+| 문자 수 | 3,132자 | 1,000+ | ✅ 적절 | ✅ 정상 |
+
+**문제 진단**:
+- 전체적으로 정상이나 특정 문장만 비정상적으로 김
+- 문단 분할 실패 가능성 (여러 문장이 하나로 합쳐짐)
+- 리스트나 긴 설명문이 마침표 없이 작성되었을 가능성
+
+**조치 방안**:
+- ✅ **학습 데이터로 사용 가능 (기본)**
+- 옵션 1: 해당 문장(259자) 수동 확인 후 분할
+- 옵션 2: 그대로 사용 (나머지 품질이 양호하므로)
+- 권장: **그대로 사용** (1개 문장만의 문제이므로 전체 품질에 영향 미미)
+
+---
+
+### 5.4 품질 필터링 기준
+
+다음 기준으로 데이터를 필터링하면 고품질 데이터셋 확보 가능:
+
+```python
+# 품질 필터링 기준
+quality_criteria = {
+    'min_chars': 200,                 # 최소 200자 이상
+    'max_avg_sentence_len': 30,       # 평균 문장 길이 30자 이하
+    'max_special_ratio': 0.15,        # 특수문자 15% 이하
+    'max_punct_ratio': 0.20,          # 구두점 20% 이하
+    'min_sentences': 5,               # 최소 5문장 이상
+    'max_sentence_len': 200           # 최대 문장 200자 이하 (선택)
+}
+```
+
+**필터링 결과 예상**:
+- 제외 예상: 2-3개
+- 유지 예상: 97-98개
+- 유지율: **97-98%**
+
+> **💡 활용 방안**  
+> - **자동 필터링**: 위 기준으로 자동 품질 검사 스크립트 작성
+> - **수동 검토**: 경계선상의 파일(3-5개)만 수동으로 최종 판단
+> - **버전 관리**: 원본(100개), 필터링 후(97개) 버전 모두 보관
+
+---
+
+## 6. 주요 인사이트 및 활용 방안
+
+### 6.1 데이터 품질 인사이트
+
+| # | 인사이트 | 근거 | 활용 방안 |
+|---|---------|------|----------|
+| 1 | **HWP 추출 품질 우수** | 96개 중 95개 정상 (98.9%) | HWP 파일을 주요 학습 데이터로 사용 |
+| 2 | **PDF 추출 품질 불량** | 4개 중 1개 심각한 문제 (25%) | PDF는 재추출 시도 후 개선 없으면 제외 |
+| 3 | **문장 길이 분포 양호** | 평균 15.9자, 표준편차 5.6 | 한국어 자연어 처리에 적합한 데이터 |
+| 4 | **특수문자 비율 낮음** | 평균 2.0%, 95개가 5% 이하 | 깨끗한 텍스트, 전처리 부담 적음 |
+| 5 | **데이터 불균형 심각** | HWP:PDF = 96:4 비율 | PDF 추가 수집 또는 HWP만 사용 |
+| 6 | **문서 길이 적절** | 평균 3,835자 ≈ 2,000 토큰 | LLM 컨텍스트 윈도우에 적합 |
+| 7 | **이상치 최소** | 98% 정상, 2% 이상치 | 높은 데이터 품질, 소수 파일만 처리 |
+
+### 6.2 모델별 활용 전략
+
+#### 🔍 RAG 시스템
+
+**데이터 특성 기반 전략**:
+```python
+rag_config = {
+    # 청크 설정
+    'chunk_size': 512,              # 평균 문서 ≈ 2,000 토큰 고려
+    'chunk_overlap': 50,            # 10% 오버랩
+    'chunking_method': 'semantic',  # 문장 단위 분할
+    
+    # 예상 청크 수
+    'chunks_per_doc': 4-5,          # 평균 문서 길이 기준
+    'total_chunks': 400-500,        # 100개 문서 기준
+    
+    # 메타데이터
+    'metadata_fields': [
+        'filename',
+        'organization',             # 발주기관
+        'category',                 # 사업 분류
+        'year'                      # 연도
+    ],
+    
+    # 검색 설정
+    'top_k': 5,                     # 상위 5개 청크 검색
+    'similarity_metric': 'cosine'
+}
+```
+
+**최적화 포인트**:
+- 평균 문서 길이가 적절 → 과도한 잘라내기 불필요
+- 문장 구조 양호 → 문장 단위 청크 분할 효과적
+- 특수문자 적음 → 임베딩 품질 우수 예상
+
+> **💡 실제 적용**  
+> 1. 98개 정상 문서로 Vector DB 구축
+> 2. 문서당 4-5개 청크 → 총 약 490개 청크
+> 3. 한국어 임베딩 모델 사용 (KoSimCSE, multilingual-e5 등)
+
+---
+
+#### 🎓 Fine-tuning
+
+**데이터 현황 평가**:
+- **사용 가능 데이터**: 97-98개 (문제 파일 제외 후)
+- **데이터 분할**: Train 78개, Val 10개, Test 10개
+- **규모 평가**: 프로토타입용으로는 적절, 프로덕션용으로는 부족
+
+**전처리 전략**:
+```python
+finetuning_config = {
+    # 품질 필터링
+    'min_chars': 200,
+    'max_avg_sentence_len': 30,
+    'max_special_ratio': 0.15,
+    
+    # 토큰 길이 제한
+    'max_input_tokens': 2048,       # 평균 문서 포함 가능
+    'max_output_tokens': 512,       # 요약문
+    
+    # 데이터 분할
+    'train_ratio': 0.8,             # 78-80개
+    'val_ratio': 0.1,               # 10개
+    'test_ratio': 0.1,              # 10개
+    
+    # 포맷
+    'format': 'chat',               # Chat format 사용
+    'system_prompt': '당신은 공공기관 문서 요약 전문가입니다.'
+}
+```
+
+**한계점 및 대응**:
+- ⚠️ **데이터 부족**: 100개는 소규모 (이상적으로 500-1,000개 필요)
+- ✅ **대응 방안**:
+  1. 데이터 증강 (역번역, 패러프레이즈)
+  2. Few-shot Learning 활용
+  3. 기존 모델에서 계속 학습 (Continued Pre-training)
+  4. 추가 데이터 수집
+
+> **💡 실제 적용**  
+> - Phase 1: 현재 데이터로 프로토타입 Fine-tuning
+> - Phase 2: 성능 평가 후 데이터 확장 여부 결정
+> - 목표: 데이터 300개 이상 확보 시 본격 Fine-tuning
+
+---
+
+#### 🤖 API 기반 모델
+
+**데이터 특성 활용**:
+```python
+api_config = {
+    # 프롬프트 설계
+    'avg_doc_length': 3835,         # 평균 문서 길이
+    'avg_tokens': 2000,             # 약 2,000 토큰
+    
+    # 비용 예측
+    'input_cost_per_1k': 0.01,      # GPT-4 기준 예시
+    'output_cost_per_1k': 0.03,
+    'expected_output': 256,         # 요약문 토큰
+    
+    # 문서당 비용
+    'cost_per_doc': (2000 * 0.01 / 1000) + (256 * 0.03 / 1000),
+    # = $0.0276/문서
+    
+    # 캐싱 전략
+    'cache_similar_docs': True,     # 유사 문서 캐싱
+    'cache_ttl': 86400,             # 24시간
+    'expected_cache_hit': 0.3       # 30% 캐시 적중률
+}
+```
+
+**최적화 전략**:
+1. **토큰 수 최적화**: 
+   - 평균 2,000 토큰 → 대부분 문서가 한 번에 처리 가능
+   - 긴 문서(>4,000 토큰)만 잘라내기 또는 요약 후 재요약
+
+2. **캐싱 활용**:
+   - 유사한 문서 패턴 많음 (공공기관 제안요청서)
+   - 캐싱으로 30-40% 비용 절감 가능
+
+3. **모델 선택**:
+   - 간단한 요약: GPT-3.5-Turbo (저렴)
+   - 복잡한 요약: GPT-4 (고품질)
+   - A/B 테스트로 성능-비용 최적 지점 찾기
+
+> **💡 실제 적용**  
+> - 100개 문서 요약 비용: 약 $2.76 (캐싱 없을 때)
+> - 캐싱 30% 적용 시: 약 $1.93
+> - 프로토타입으로 충분히 활용 가능한 비용
+
+---
+
+### 6.3 프로젝트 진행 가능성 평가
+
+#### ✅ 현재 데이터로 가능한 것
+
+| 작업 | 가능 여부 | 데이터 충분성 | 비고 |
+|------|----------|-------------|------|
+| RAG 프로토타입 | ✅ 가능 | 충분 | 98개 문서면 충분 |
+| API 기반 요약 | ✅ 가능 | 충분 | 테스트 및 검증 가능 |
+| Fine-tuning 실험 | ✅ 가능 | 최소 요건 | 프로토타입 수준 |
+| 성능 평가 | ✅ 가능 | 충분 | Test set 10개로 평가 |
+| A/B 테스트 | ✅ 가능 | 충분 | 비교 실험 가능 |
+
+#### ⚠️ 추가 작업 필요한 것
+
+| 작업 | 필요 작업 | 현재 상태 | 목표 |
+|------|----------|---------|------|
+| 대규모 Fine-tuning | 데이터 확장 | 98개 | 300-500개 |
+| 프로덕션 배포 | 데이터 검증 | 테스트 단계 | 안정화 |
+| PDF 처리 안정화 | 추출 개선 | 25% 실패율 | 95%+ 성공률 |
+| 다양한 문서 타입 | 데이터 수집 | 단일 도메인 | 멀티 도메인 |
+
+#### 📊 데이터 품질 종합 점수
+
+| 평가 항목 | 점수 | 설명 |
+|----------|------|------|
+| 데이터 양 | ⭐⭐⭐☆☆ | 프로토타입 가능, 실서비스 부족 |
+| 추출 품질 | ⭐⭐⭐⭐☆ | HWP 우수(98.9%), PDF 문제 |
+| 데이터 균형 | ⭐☆☆☆☆ | 심각한 불균형 (96:4) |
+| 텍스트 품질 | ⭐⭐⭐⭐☆ | 문장 구조 양호, 노이즈 적음 |
+| 일관성 | ⭐⭐⭐⭐☆ | 동일 도메인, 유사한 구조 |
+| **종합 평가** | **⭐⭐⭐☆☆** | **프로토타입 개발 가능, 개선 필요** |
+
+---
+
+### 6.4 최종 권장 전략
+
+#### Phase 1: 현재 데이터 활용 (즉시 시작 가능)
+
+**우선순위 1 - RAG 시스템**:
+```
+목표: 문서 검색 기반 QA 시스템 구축
+데이터: 98개 HWP 문서
+예상 기간: 1-2주
+성공 가능성: 높음 (⭐⭐⭐⭐⭐)
+```
+
+**우선순위 2 - API 모델**:
+```
+목표: GPT/Claude 기반 요약 시스템
+데이터: 100개 문서로 프롬프트 최적화
+예상 기간: 1��
+성공 가능성: 매우 높음 (⭐⭐⭐⭐⭐)
+```
+
+**우선순위 3 - Fine-tuning 실험**:
+```
+목표: 소규모 모델 Fine-tuning 실험
+데이터: 98개 (요약문 필요)
+예상 기간: 2-3주
+성공 가능성: 중간 (⭐⭐⭐☆☆)
+조건: 요약문 데이터 확보 필요
+```
+
+#### Phase 2: 데이터 확장 후 (3-6개월)
+
+**데이터 확장 목표**:
+- 현재: 100개 → 목표: 300-500개
+- PDF 비율: 4% → 목표: 20-30%
+- 도메인: 단일 → 목표: 다중 (교육, 의료, 행정 등)
+
+**확장 후 가능한 작업**:
+- 본격적인 Fine-tuning (성능 향상 기대)
+- 프로덕션 레벨 서비스 배포
+- 다양한 도메인 문서 지원
+
+---
+
+### 6.5 팀별 액션 아이템
+
+#### 데이터 전처리 담당
+- [ ] 고려대학교 PDF 파일 제외
+- [ ] 나머지 PDF 3개 재추출 시도
+- [ ] 품질 필터링 스크립트 작성
+- [ ] 최종 데이터셋 97-98개 준비
+- [ ] 형식별 데이터 분리 (RAG용 청크, Fine-tuning용 페어)
+
+#### RAG 담당자
+- [ ] 98개 문서로 Vector DB 구축
+- [ ] 한국어 임베딩 모델 선택
+- [ ] 청크 크기 512 토큰으로 설정
+- [ ] 검색 성능 테스트 (Recall@5 > 80% 목표)
+
+#### API 개발자
+- [ ] 평균 문서 길이 기준 프롬프트 설계
+- [ ] GPT-4 vs GPT-3.5 A/B 테스트
+- [ ] 비용 최적화 (캐싱, 토큰 절감)
+- [ ] 100개 문서 테스트 실행
+
+#### Fine-tuning 담당자 (선택)
+- [ ] 요약문 데이터 확보 방안 검토
+- [ ] API로 요약문 생성 (임시)
+- [ ] 소규모 실험 진행
+- [ ] 성능 평가 및 데이터 확장 필요성 판단
+
+---
+
+**보고서 끝**

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dongjin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,145 @@
+# Codeit-AI-1team-LLM-project
+---
+## 챗봇 서비스 시연
+![VectorDB Dashboard](asset/chatbot.gif)
+
+## 벡터 DB 대시보드 영상
+![VectorDB Dashboard](asset/vectorDB.gif)
+
+# 1. 프로젝트 개요
+- **B2G 입찰지원 전문 컨설팅 스타트업 – 'RFPilot'**
+- RFP 문서를 요약하고, 사용자 질문에 실시간으로 응답하는 챗봇 시스템
+> **배경**: 매일 수백 건의 기업 및 정부 제안요청서(RFP)가 게시되는데, 각 요청서 당 수십 페이지가 넘는 문건을 모두 검토하는 것은 불가능합니다. 이러한 과정은 비효율적이며, 중요한 정보를 빠르게 파악하기 어렵습니다.
+> 
+> **목표**: 사용자의 질문에 실시간으로 응답하고, 관련 제안서를 탐색하여 요약 정보를 제공하는 챗봇을 개발하여 컨설턴트의 업무 효율을 향상시키고자 합니다.
+> 
+> **기대 효과**: RAG 시스템을 통해 중요한 정보를 신속하게 제공함으로써, 제안서 검토 시간을 단축하고 컨설팅 업무에 보다 집중할 수 있는 환경을 조성합니다.
+---
+# 2. 설치 및 실행(🪟 Windows)
+---
+### Prerequisites
+- Python 3.12.3 설치됨
+- Poetry 설치됨
+- 저장소 클론 완료
+- 데이터셋 로컬에 저장
+- 양자화된 모델 파일(.gguf) 저장
+- .env 생성(api키 입력)
+
+**env 파일 설정 방법**
+```env
+OPENAI_API_KEY = "OpenAI API 키"
+WANDB_API_KEY = "WanDB API 키"
+LANGCHAIN_TRACING_V2=true
+LANGSMITH_API_KEY = "LangSmith API 키"
+LANGCHAIN_PROJECT = "LangSmith 프로젝트 이름"
+```
+
+**코드 실행**
+```powershell
+# 1. 프로젝트 폴더로 이동
+cd Codeit-AI-1team-LLM-project
+
+# 2. 가상환경 설정 및 의존성 설치
+python -m poetry config virtualenvs.in-project true
+python -m poetry env use 3.12.3
+python -m poetry install
+
+# 3. 가상환경 활성화
+python -m poetry env activate
+
+# 4. 실행(전처리~벡터DB 구측)
+python -m poetry run python main.py --step all
+
+# 5. 벡터 DB 대시보드 실행
+python -m poetry run streamlit run src/visualization/streamlit_app.py
+
+# 6. 챗봇 서비스 실행
+python -m poetry run streamlit run src/visualization/chatbot_app.py
+
+# 7. LangSmith 실험 실행(API 및 프로젝트 생성 필요)
+python -m poetry run python src/evaluation/run_experiment.py              # 대화형 메뉴
+python -m poetry run python src/evaluation/run_experiment.py --run        # 실험 실행
+python -m poetry run python src/evaluation/run_experiment.py --compare    # 실험 비교
+```
+
+# 3. 프로젝트 구조
+---
+```
+CODEIT-AI-1TEAM-LLM-PROJECT/
+│
+├── main.py                  # 실행 진입점
+├── models/                  # 로컬 모델 로드용 양자화 파일 저장 폴더(비공개)
+├── data/                    # 문서 및 벡터DB 저장 폴더(비공개)
+│   ├── files/               # hwp, pdf 문서
+│   └── data_list.csv        # RFP 문서 정보 csv
+├── src/
+│   ├── loader/              # 문서 로딩 및 전처리
+│   ├── evaluation/          # LangSmith 평가
+│   ├── embedding/           # 임베딩, 벡터DB 생성
+│   ├── retriever/           # 문서 검색기
+│   ├── generator/           # 응답 생성기
+│   ├── visualization/       # UI 구성
+│   ├── notebooks/           # Hugging Face 모델 학습 코드
+│   └── utils/               # 공통 함수 모듈
+└── README.md
+```
+- `main.py`: 전체 RAG 파이프라인 실행의 진입점입니다.
+- `data/`: 원문 문서, 생성된 벡터DB 등이 저장됩니다.
+- `models/`: 로컬 모델 로드용 양자화 모델 파일을 저장하는 곳입니다.
+- `src/loader`: PDF, HWP 문서를 텍스트로 추출하고 의미 단위로 분할합니다.
+- `src/evaluation`: LangSmith 평가 환경을 관리하고 실험을 진행합니다.
+- `src/embedding`: 텍스트 임베딩 벡터를 생성하고 Chroma DB를 구축합니다.
+- `src/retriever`: 사용자 질문에 대한 관련 문서를 벡터DB에서 검색합니다.
+- `src/generator`: 검색된 문서 기반으로 LLM이 응답을 생성합니다.
+- `src/notebooks`: 로컬 모델을 Fine-Tuning하여 양자화 파일을 생성합니다.
+- `src/visualization`: Streamlit 기반 사용자 인터페이스를 구성합니다.
+- `src/utils`: 설정 확인, 경로 설정 등 공통 유틸리티 함수들을 포함합니다.
+
+# 4. 팀 소개
+> 기본에 충실실하며 실제 사용 가능한 모델을 만들기 위해 끊임없이 노력하는 팀입니다.
+
+## 👨🏼‍💻 멤버 구성
+|지동진|김진욱|이유노|박지윤|
+|-----|------|------|-------|
+|<img width="100" height="100" alt="image" src="https://github.com/user-attachments/assets/b9f1a52f-4304-496d-a19c-2d6b4775a5c3" />|<img width="100" height="100" alt="image" src="https://avatars.githubusercontent.com/u/80089860?v=4.png"/>|<img width="100" height="100" alt="image" src="https://github.com/user-attachments/assets/4e635630-f00c-4026-bb1d-c73ec05f37c8" />|<img width="100" height="100" alt="image" src="https://github.com/user-attachments/assets/088a073c-cf1c-40a1-97fb-1d2c1f1b8794" />|
+|![https://github.com/Dongjin-1203](https://img.shields.io/badge/github-181717?style=for-the-badge&logo=github&logoColor=white)|![https://github.com/Jinuk93](https://img.shields.io/badge/github-181717?style=for-the-badge&logo=github&logoColor=white)|![https://github.com/Leeyuno0419](https://img.shields.io/badge/github-181717?style=for-the-badge&logo=github&logoColor=white)|![https://github.com/krapnuyij](https://img.shields.io/badge/github-181717?style=for-the-badge&logo=github&logoColor=white)|
+|![hamubr1203@gmail.com](https://img.shields.io/badge/Gmail-D14836?style=for-the-badge&logo=gmail&logoColor=white)|![rlawlsdnr430@gmail.com](https://img.shields.io/badge/Gmail-D14836?style=for-the-badge&logo=gmail&logoColor=white)|![yoonolee0419@gmail.com](https://img.shields.io/badge/Gmail-D14836?style=for-the-badge&logo=gmail&logoColor=white)|![jiyun1147@gmail.com](https://img.shields.io/badge/Gmail-D14836?style=for-the-badge&logo=gmail&logoColor=white)|
+
+## 👨🏼‍💻 역할 분담
+|지동진|김진욱|이유노|박지윤|
+|------|--------------|---------------|---------------|
+|PM/AI Enginner(Rettriever, Pre-trained, PEFT)|Data Scientist|AI Engineer(API, Prompt)|AI Engineer(HuggingFace, PEFT)|
+|프로젝트 총괄. 팀 회의 진행. 팀 혐업 환경 관리. RAG 개발. 대시보드 개발, PEFT 담당|학습 데이터 구성. 데이터 전처리 파이프라인 작성. 개발간 필요한 인사이트 도출 및 정보 수집, 제공|API 모델 개발. 프롬프트 작성. 모델 개선|HuggingFace 모델 학습, 모델 개선|
+---
+# 5. 프로젝트 타임라인
+<img width="1580" height="807" alt="image" src="https://github.com/user-attachments/assets/57f6346a-663f-4ddd-a4b6-fafc2074ff71" />
+
+
+---
+# 6. 서비스 설명
+
+## 서비스 아키텍쳐
+<img width="4208" height="2004" alt="image" src="https://github.com/user-attachments/assets/73a0db09-b858-4b69-b93b-a85f928225a9" />
+
+---
+# Further Information
+
+## 개발 스택 및 개발환경
+- **언어**: <img width="67" height="18" alt="image" src="https://github.com/user-attachments/assets/e8035e3d-cadb-48f5-a4ac-3693faca01a7" /> <img width="67" height="18" alt="image" src="https://github.com/user-attachments/assets/0658c7ba-8039-4dc3-96a2-7c1308b2fafc" />
+
+- **프레임워크**: <img width="79" height="18" alt="image" src="https://github.com/user-attachments/assets/e8814092-7e1e-4b22-8d77-e04fd2b26ae6" /> <img width="79" height="18" alt="image" src="https://img.shields.io/badge/LangChain-ffffff?logo=langchain&logoColor=green" />
+
+- **라이브러리**: <img width="71" height="18" alt="image" src="https://github.com/user-attachments/assets/a428cd24-c8a5-4296-b6da-22eb322afa49" /> <img width="69" height="18" alt="image" src="https://github.com/user-attachments/assets/4325f1d3-d8ba-4bec-a746-4cad4993e925" /> <img width="103" height="18" alt="image" src="https://github.com/user-attachments/assets/a2009044-329d-4dde-b0dc-701122ff8149" /> <img width="53" height="18" alt="image" src="https://github.com/user-attachments/assets/f6225115-0b60-439e-8388-974a0365f8d6" /> 
+- **클라우드 서비스**: <img width="71" height="18" alt="image" src="https://img.shields.io/badge/Google%20Cloud-4285F4?&style=plastic&logo=Google%20Cloud&logoColor=white" />
+- **도구**: <img width="65" height="18" alt="image" src="https://github.com/user-attachments/assets/52f296c1-c878-4285-abe6-74842522e793" /> <img width="89" height="18" alt="image" src="https://github.com/user-attachments/assets/4ac10441-0753-4e94-9237-1ea6dc2034a2" /><img width="63" height="18" alt="image" src="https://github.com/user-attachments/assets/fea30130-c47c-4fa7-b3cb-7531481cfb28" /> <img width="89" height="18" alt="image" src="https://img.shields.io/badge/google_drive-white?style=for-the-badge&logo=google%20drive&logoColor=white&color=%23EA4336" />
+
+
+
+## 협업 Tools
+<img width="69" height="18" alt="image" src="https://github.com/user-attachments/assets/2bc2fa93-b01e-4051-9b31-ab83301594df" />
+<img width="63" height="18" alt="image" src="https://github.com/user-attachments/assets/6c44ddad-80a4-4098-9727-6dae9a8fcb1c" />
+<img width="65" height="18" alt="image" src="https://github.com/user-attachments/assets/a85b2d0f-8cdc-43e7-8e14-da11708a33a4" />
+<img width="89" height="18" alt="image" src="https://github.com/user-attachments/assets/28d7f511-a4fe-4aa5-9184-2d3a94a97f29" />
+<img width="89" height="18" alt="image" src="https://img.shields.io/badge/weightsandbiases-%23FFBE00?style=for-the-badge&logo=wandb-%23FFBE00&logoColor=%23FFBE00" />
+
+## 기타 링크

chroma_db/29e2b771-69ae-4fd1-9025-9dda88ce7e45/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fcbbabd5eddf6c36f238edc7dc7a17aeab05cbfefb8456caad3495309403abd
+size 59176428

chroma_db/29e2b771-69ae-4fd1-9025-9dda88ce7e45/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4b516f13e8eb37f410c5a087df870dcbc2994a316d8e58efd5f1bac5685d422
+size 100

chroma_db/29e2b771-69ae-4fd1-9025-9dda88ce7e45/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c79083c508105b134cb2ba307430bd2afa033a91d5a22703a94f6745856998a
+size 2100188

chroma_db/29e2b771-69ae-4fd1-9025-9dda88ce7e45/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:318eb571e3c7704e576e589ab175992efdef54cddae6147eeb214efd2791c320
+size 37668

chroma_db/29e2b771-69ae-4fd1-9025-9dda88ce7e45/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ba1f25b966f8671e2cbf5181c811630577e89dd4c1fa3eb5ef43d0bf1f7d3de
+size 79488

chroma_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3c8f47065976eb17aac628524373ea64a6b3c3259bcb341de5da50fa4409779
+size 187174912

data/rag_chunks_final.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c833ced843410dca02c5f0bd83c89d9e3d64c9211683abaa8f24b1de1d16412
+size 29074806

main.py

@@ -0,0 +1,237 @@
+"""
+RAG 전체 파이프라인 실행 스크립트
+
+단계:
+1. 전처리 (preprocess): 텍스트 추출 → 정제 → 청킹
+2. 임베딩 (embed): 청크 벡터화 → ChromaDB 저장
+3. RAG (rag): RAG 파이프라인 테스트 (선택)
+
+사용법:
+    python main.py --step all              # 전체 실행
+    python main.py --step preprocess       # 전처리만
+    python main.py --step embed            # 임베딩만
+    python main.py --step rag              # RAG 테스트만
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from src.utils.config import PreprocessConfig
+from src.loader.preprocess_pipeline import RAGPreprocessPipeline
+
+
+def parse_arguments():
+    """커맨드 라인 인자 파싱"""
+    parser = argparse.ArgumentParser(
+        description='RAG 전체 파이프라인 실행',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+예시:
+  python main.py --step all                    # 전체 파이프라인 실행
+  python main.py --step preprocess             # 전처리만 실행
+  python main.py --step embed                  # 임베딩만 실행
+  python main.py --step rag --query "질문"    # RAG 테스트
+  
+  python main.py --step preprocess --chunk-size 500  # 청크 크기 조정
+        """
+    )
+    
+    # 실행 단계 선택
+    parser.add_argument(
+        '--step',
+        type=str,
+        choices=['all', 'preprocess', 'embed', 'rag'],
+        default='all',
+        help='실행할 단계 (기본값: all)'
+    )
+    
+    # 전처리 관련 인자
+    preprocess_group = parser.add_argument_group('전처리 옵션')
+    preprocess_group.add_argument(
+        '--meta-csv',
+        type=str,
+        default='./data/data_list.csv',
+        help='메타데이터 CSV 파일 경로'
+    )
+    preprocess_group.add_argument(
+        '--files-dir',
+        type=str,
+        default='./data/files/',
+        help='원본 파일 폴더 경로'
+    )
+    preprocess_group.add_argument(
+        '--output-chunks',
+        type=str,
+        default='./data/rag_chunks_final_small.csv',
+        help='청크 출력 파일 경로'
+    )
+    preprocess_group.add_argument(
+        '--chunk-size',
+        type=int,
+        default=1000,
+        help='청크 크기'
+    )
+    preprocess_group.add_argument(
+        '--chunk-overlap',
+        type=int,
+        default=200,
+        help='청크 오버랩'
+    )
+    
+    # RAG 관련 인자
+    rag_group = parser.add_argument_group('RAG 옵션')
+    rag_group.add_argument(
+        '--query',
+        type=str,
+        help='RAG 질의 (rag 단계에서만 사용)'
+    )
+    
+    return parser.parse_args()
+
+
+def step_preprocess(args):
+    """1단계: 전처리 실행"""
+    print("\n" + "="*70)
+    print("🔧 1단계: 데이터 전처리 시작")
+    print("="*70)
+    
+    # 설정 초기화
+    config = PreprocessConfig()
+    config.META_CSV_PATH = args.meta_csv
+    config.BASE_FOLDER_PATH = args.files_dir
+    config.OUTPUT_CHUNKS_PATH = args.output_chunks
+    config.CHUNK_SIZE = args.chunk_size
+    config.CHUNK_OVERLAP = args.chunk_overlap
+    
+    # 전처리 파이프라인 실행
+    pipeline = RAGPreprocessPipeline(config)
+    df_chunks = pipeline.run()
+    
+    print("\n" + "="*70)
+    print("✅ 1단계: 전처리 완료")
+    print("="*70)
+    print(f"📁 출력 파일: {config.OUTPUT_CHUNKS_PATH}")
+    print(f"📊 총 청크 수: {len(df_chunks)}")
+    
+    return df_chunks
+
+
+def step_embed(args):
+    """2단계: 임베딩 및 ChromaDB 저장"""
+    print("\n" + "="*70)
+    print("🔧 2단계: 임베딩 및 벡터DB 구축 시작")
+    print("="*70)
+    
+    try:
+        # 임베딩 모듈 임포트
+        from src.embedding.rag_data_processing import RAGVectorDBPipeline
+        
+        # 임베딩 실행
+        pipeline = RAGVectorDBPipeline()
+        vectorstore = pipeline.build()
+        
+        print("\n" + "="*70)
+        print("✅ 2단계: 임베딩 완료")
+        print("="*70)
+        
+    except ImportError as e:
+        print(f"⚠️  임베딩 모듈을 찾을 수 없습니다: {e}")
+        print("   src/embedding/rag_data_processing.py 파일이 있는지 확인하세요.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ 임베딩 실행 중 오류 발생: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+def step_rag(args):
+    """3단계: RAG 파이프라인 테스트"""
+    print("\n" + "="*70)
+    print("🔧 3단계: RAG 파이프라인 테스트")
+    print("="*70)
+    
+    try:
+        # RAG 모듈 임포트
+        from src.generator.generator import RAGPipeline
+        from src.utils.rag_config import RAGConfig
+        
+        # RAG 설정
+        config = RAGConfig()
+        
+        # RAG 파이프라인 초기화
+        rag = RAGPipeline(config=config)
+        
+        # 테스트 질의 실행
+        if args.query:
+            print(f"\n📝 질의: {args.query}")
+            result = rag.generate_answer(args.query)
+            
+            print(f"\n💬 답변:")
+            print(result['answer'])
+            print(f"\n📚 참고 문서: {len(result.get('sources', []))}개")
+            print(f"🔢 토큰 사용: {result['usage']['total_tokens']}")
+        else:
+            print("\n⚠️  --query 인자가 없어 테스트 질의를 건너뜁니다.")
+            print("   예시: python main.py --step rag --query '한영대학교 특성화 사업은?'")
+        
+        print("\n" + "="*70)
+        print("✅ 3단계: RAG 파이프라인 완료")
+        print("="*70)
+        
+    except ImportError as e:
+        print(f"⚠️  RAG 모듈을 찾을 수 없습니다: {e}")
+        print("   src/generator/rag_pipeline.py 파일이 있는지 확인하세요.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ RAG 실행 중 오류 발생: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+def main():
+    """메인 실행 함수"""
+    args = parse_arguments()
+    
+    print("="*70)
+    print("🚀 RAG 전체 파이프라인")
+    print("="*70)
+    print(f"실행 단계: {args.step}")
+    
+    try:
+        if args.step == 'all':
+            # 전체 파이프라인 실행
+            step_preprocess(args)
+            step_embed(args)
+            
+            # RAG 테스트는 선택적 (query가 있으면 실행)
+            if args.query:
+                step_rag(args)
+            
+        elif args.step == 'preprocess':
+            step_preprocess(args)
+            
+        elif args.step == 'embed':
+            step_embed(args)
+            
+        elif args.step == 'rag':
+            step_rag(args)
+        
+        print("\n" + "="*70)
+        print("🎉 모든 작업 완료!")
+        print("="*70)
+        
+    except KeyboardInterrupt:
+        print("\n\n⚠️  사용자에 의해 중단되었습니다.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n❌ 오류 발생: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

notebooks/export_v2.py

@@ -0,0 +1,47 @@
+from unsloth import FastLanguageModel
+import torch
+import os
+import glob
+
+# ==========================================
+# [Smart Export Script] 최신 체크포인트 자동 감지
+# ==========================================
+
+print(">>> [System] GGUF 변환 작업을 시작합니다...")
+
+# 1. 최신 체크포인트 폴더 찾기 (핵심!)
+output_dir = "outputs_final"
+
+if not os.path.exists(output_dir):
+    print(f">>> [Error] '{output_dir}' 폴더가 없습니다!")
+    exit()
+
+# checkpoint- 숫자 폴더들을 다 찾아서 숫자가 제일 큰 놈을 고름
+subfolders = [f.path for f in os.scandir(output_dir) if f.is_dir() and "checkpoint" in f.name]
+
+if not subfolders:
+    print(">>> [Error] 체크포인트 폴더를 찾을 수 없습니다!")
+    exit()
+
+# 숫자로 정렬해서 가장 마지막 것 선택 (예: checkpoint-3171)
+latest_checkpoint = max(subfolders, key=lambda x: int(x.split('-')[-1]))
+
+print(f">>> [Found] 가장 학습이 잘 된 모델을 찾았습니다: {latest_checkpoint}")
+print(">>> [Model] 모델 로드 중... (xFormers 경고는 무시하세요)")
+
+# 2. 모델 로드 (정확한 경로 입력)
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name = latest_checkpoint, # <--- 자동으로 찾은 경로
+    max_seq_length = 2048,
+    dtype = None,
+    load_in_4bit = True,
+)
+
+# 3. GGUF 변환
+print(f">>> [Convert] '{latest_checkpoint}' -> GGUF 변환 시작 (5~10분 소요)")
+
+# q4_k_m: 용량/성능 밸런스형
+model.save_pretrained_gguf("BiddinMate_Model", tokenizer, quantization_method = "q4_k_m")
+
+print(">>> [Success] 변환 완료!")
+print(f">>> 'BiddinMate_Model' 폴더 안에 .gguf 파일이 생성되었습니다.")

notebooks/llama.ipynb

@@ -0,0 +1,887 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d13f7470",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "print(torch.cuda.is_available())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d944a23b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: torch in /opt/jhub-venv/lib/python3.12/site-packages (2.6.0+cu124)\n",
+      "Requirement already satisfied: transformers in ./myenv/lib/python3.12/site-packages (4.57.1)\n",
+      "Requirement already satisfied: peft in ./myenv/lib/python3.12/site-packages (0.18.0)\n",
+      "Requirement already satisfied: bitsandbytes in ./myenv/lib/python3.12/site-packages (0.48.2)\n",
+      "Requirement already satisfied: trl in ./myenv/lib/python3.12/site-packages (0.25.1)\n",
+      "Requirement already satisfied: datasets in ./myenv/lib/python3.12/site-packages (4.4.1)\n",
+      "Requirement already satisfied: accelerate in ./myenv/lib/python3.12/site-packages (1.11.0)\n",
+      "Requirement already satisfied: jsonlines in ./myenv/lib/python3.12/site-packages (4.0.0)\n",
+      "Requirement already satisfied: filelock in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (3.19.1)\n",
+      "Requirement already satisfied: typing-extensions>=4.10.0 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (4.15.0)\n",
+      "Requirement already satisfied: networkx in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (3.5)\n",
+      "Requirement already satisfied: jinja2 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (3.1.6)\n",
+      "Requirement already satisfied: fsspec in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (2025.9.0)\n",
+      "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.4.127 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (12.4.127)\n",
+      "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.4.127 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (12.4.127)\n",
+      "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.4.127 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (12.4.127)\n",
+      "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (9.1.0.70)\n",
+      "Requirement already satisfied: nvidia-cublas-cu12==12.4.5.8 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (12.4.5.8)\n",
+      "Requirement already satisfied: nvidia-cufft-cu12==11.2.1.3 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (11.2.1.3)\n",
+      "Requirement already satisfied: nvidia-curand-cu12==10.3.5.147 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (10.3.5.147)\n",
+      "Requirement already satisfied: nvidia-cusolver-cu12==11.6.1.9 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (11.6.1.9)\n",
+      "Requirement already satisfied: nvidia-cusparse-cu12==12.3.1.170 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (12.3.1.170)\n",
+      "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (0.6.2)\n",
+      "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (2.21.5)\n",
+      "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (12.4.127)\n",
+      "Requirement already satisfied: nvidia-nvjitlink-cu12==12.4.127 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (12.4.127)\n",
+      "Requirement already satisfied: triton==3.2.0 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (3.2.0)\n",
+      "Requirement already satisfied: setuptools in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (70.2.0)\n",
+      "Requirement already satisfied: sympy==1.13.1 in /opt/jhub-venv/lib/python3.12/site-packages (from torch) (1.13.1)\n",
+      "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /opt/jhub-venv/lib/python3.12/site-packages (from sympy==1.13.1->torch) (1.3.0)\n",
+      "Requirement already satisfied: huggingface-hub<1.0,>=0.34.0 in ./myenv/lib/python3.12/site-packages (from transformers) (0.36.0)\n",
+      "Requirement already satisfied: numpy>=1.17 in /opt/jhub-venv/lib/python3.12/site-packages (from transformers) (2.3.3)\n",
+      "Requirement already satisfied: packaging>=20.0 in /opt/jhub-venv/lib/python3.12/site-packages (from transformers) (25.0)\n",
+      "Requirement already satisfied: pyyaml>=5.1 in /opt/jhub-venv/lib/python3.12/site-packages (from transformers) (6.0.3)\n",
+      "Requirement already satisfied: regex!=2019.12.17 in ./myenv/lib/python3.12/site-packages (from transformers) (2025.11.3)\n",
+      "Requirement already satisfied: requests in /opt/jhub-venv/lib/python3.12/site-packages (from transformers) (2.32.5)\n",
+      "Requirement already satisfied: tokenizers<=0.23.0,>=0.22.0 in ./myenv/lib/python3.12/site-packages (from transformers) (0.22.1)\n",
+      "Requirement already satisfied: safetensors>=0.4.3 in ./myenv/lib/python3.12/site-packages (from transformers) (0.6.2)\n",
+      "Requirement already satisfied: tqdm>=4.27 in ./myenv/lib/python3.12/site-packages (from transformers) (4.67.1)\n",
+      "Requirement already satisfied: psutil in /opt/jhub-venv/lib/python3.12/site-packages (from peft) (7.1.3)\n",
+      "Requirement already satisfied: pyarrow>=21.0.0 in ./myenv/lib/python3.12/site-packages (from datasets) (22.0.0)\n",
+      "Requirement already satisfied: dill<0.4.1,>=0.3.0 in ./myenv/lib/python3.12/site-packages (from datasets) (0.4.0)\n",
+      "Requirement already satisfied: pandas in ./myenv/lib/python3.12/site-packages (from datasets) (2.3.3)\n",
+      "Requirement already satisfied: httpx<1.0.0 in /opt/jhub-venv/lib/python3.12/site-packages (from datasets) (0.28.1)\n",
+      "Requirement already satisfied: xxhash in ./myenv/lib/python3.12/site-packages (from datasets) (3.6.0)\n",
+      "Requirement already satisfied: multiprocess<0.70.19 in ./myenv/lib/python3.12/site-packages (from datasets) (0.70.18)\n",
+      "Requirement already satisfied: attrs>=19.2.0 in /opt/jhub-venv/lib/python3.12/site-packages (from jsonlines) (25.4.0)\n",
+      "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in ./myenv/lib/python3.12/site-packages (from fsspec[http]<=2025.10.0,>=2023.1.0->datasets) (3.13.2)\n",
+      "Requirement already satisfied: anyio in /opt/jhub-venv/lib/python3.12/site-packages (from httpx<1.0.0->datasets) (4.11.0)\n",
+      "Requirement already satisfied: certifi in /opt/jhub-venv/lib/python3.12/site-packages (from httpx<1.0.0->datasets) (2025.10.5)\n",
+      "Requirement already satisfied: httpcore==1.* in /opt/jhub-venv/lib/python3.12/site-packages (from httpx<1.0.0->datasets) (1.0.9)\n",
+      "Requirement already satisfied: idna in /opt/jhub-venv/lib/python3.12/site-packages (from httpx<1.0.0->datasets) (3.11)\n",
+      "Requirement already satisfied: h11>=0.16 in /opt/jhub-venv/lib/python3.12/site-packages (from httpcore==1.*->httpx<1.0.0->datasets) (0.16.0)\n",
+      "Requirement already satisfied: hf-xet<2.0.0,>=1.1.3 in ./myenv/lib/python3.12/site-packages (from huggingface-hub<1.0,>=0.34.0->transformers) (1.2.0)\n",
+      "Requirement already satisfied: charset_normalizer<4,>=2 in /opt/jhub-venv/lib/python3.12/site-packages (from requests->transformers) (3.4.4)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /opt/jhub-venv/lib/python3.12/site-packages (from requests->transformers) (2.5.0)\n",
+      "Requirement already satisfied: MarkupSafe>=2.0 in /opt/jhub-venv/lib/python3.12/site-packages (from jinja2->torch) (2.1.5)\n",
+      "Requirement already satisfied: python-dateutil>=2.8.2 in /opt/jhub-venv/lib/python3.12/site-packages (from pandas->datasets) (2.9.0.post0)\n",
+      "Requirement already satisfied: pytz>=2020.1 in ./myenv/lib/python3.12/site-packages (from pandas->datasets) (2025.2)\n",
+      "Requirement already satisfied: tzdata>=2022.7 in /opt/jhub-venv/lib/python3.12/site-packages (from pandas->datasets) (2025.2)\n",
+      "Requirement already satisfied: aiohappyeyeballs>=2.5.0 in ./myenv/lib/python3.12/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.10.0,>=2023.1.0->datasets) (2.6.1)\n",
+      "Requirement already satisfied: aiosignal>=1.4.0 in ./myenv/lib/python3.12/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.10.0,>=2023.1.0->datasets) (1.4.0)\n",
+      "Requirement already satisfied: frozenlist>=1.1.1 in ./myenv/lib/python3.12/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.10.0,>=2023.1.0->datasets) (1.8.0)\n",
+      "Requirement already satisfied: multidict<7.0,>=4.5 in ./myenv/lib/python3.12/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.10.0,>=2023.1.0->datasets) (6.7.0)\n",
+      "Requirement already satisfied: propcache>=0.2.0 in ./myenv/lib/python3.12/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.10.0,>=2023.1.0->datasets) (0.4.1)\n",
+      "Requirement already satisfied: yarl<2.0,>=1.17.0 in ./myenv/lib/python3.12/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.10.0,>=2023.1.0->datasets) (1.22.0)\n",
+      "Requirement already satisfied: six>=1.5 in /opt/jhub-venv/lib/python3.12/site-packages (from python-dateutil>=2.8.2->pandas->datasets) (1.17.0)\n",
+      "Requirement already satisfied: sniffio>=1.1 in /opt/jhub-venv/lib/python3.12/site-packages (from anyio->httpx<1.0.0->datasets) (1.3.1)\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install torch transformers peft bitsandbytes trl datasets accelerate jsonlines"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20479002",
+   "metadata": {},
+   "source": [
+    "## 라이브러리 설정"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "9eba4d06",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/codeit01team/myenv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch  # ← 추가!\n",
+    "\n",
+    "# 데이터 로드\n",
+    "from datasets import load_dataset\n",
+    "from transformers import (\n",
+    "    AutoModelForCausalLM,\n",
+    "    AutoTokenizer,\n",
+    "    BitsAndBytesConfig,\n",
+    ")\n",
+    "from peft import (\n",
+    "    LoraConfig,\n",
+    "    get_peft_model,\n",
+    "    prepare_model_for_kbit_training,\n",
+    "    TaskType,\n",
+    ")\n",
+    "from trl import SFTTrainer, SFTConfig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "804cb86f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/codeit01team'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pwd"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62466cf3",
+   "metadata": {},
+   "source": [
+    "# 1. 기본 QLoRA 설정 (HuggingFace PEFT + BitsAndBytes)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0b56e9fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 1. 4-bit 양자화 설정\n",
+    "bnb_config = BitsAndBytesConfig(\n",
+    "    load_in_4bit=True,\n",
+    "    bnb_4bit_quant_type=\"nf4\",\n",
+    "    bnb_4bit_use_double_quant=True,\n",
+    "    bnb_4bit_compute_dtype=torch.bfloat16\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9a2f3aa9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 6/6 [02:13<00:00, 22.28s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 2. 모델 로드\n",
+    "model_name = \"beomi/Llama-3-Open-Ko-8B\"\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    model_name,\n",
+    "    quantization_config=bnb_config,\n",
+    "    device_map=\"auto\",\n",
+    "    trust_remote_code=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "9885213c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The history saving thread hit an unexpected error (OperationalError('database or disk is full')).History will not be written to the database.\n"
+     ]
+    }
+   ],
+   "source": [
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "tokenizer.padding_side = \"right\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0e8d4d55",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 3. kbit 학습을 위한 모델 준비\n",
+    "model = prepare_model_for_kbit_training(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "d8a4198b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 4. LoRA 설정 (핵심 모듈만 - 메모리 절약)\n",
+    "lora_config = LoraConfig(\n",
+    "    r=16,\n",
+    "    lora_alpha=32,\n",
+    "    lora_dropout=0.05,\n",
+    "    bias=\"none\",\n",
+    "    task_type=TaskType.CAUSAL_LM,\n",
+    "    target_modules=[\n",
+    "        \"q_proj\",\n",
+    "        \"k_proj\", \n",
+    "        \"v_proj\",\n",
+    "        \"o_proj\",\n",
+    "        # gate_proj, up_proj, down_proj 제거 - 성능 차이 크지 않음\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "7eaa969c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 13,631,488 || all params: 8,043,892,736 || trainable%: 0.1695\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 5. LoRA 적용\n",
+    "model = get_peft_model(model, lora_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc847247",
+   "metadata": {},
+   "source": [
+    "# 2. 데이터셋 준비 및 학습\n",
+    "\n",
+    "`HuggingFace Dataset`을 사용해야하는 이유\n",
+    "\n",
+    "- SFTTrainer가 HuggingFace Dataset을 입력으로 받음\n",
+    "- 자동으로 batching, shuffling, tokenization 처리\n",
+    "- 메모리 효율적 (lazy loading)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "17143379",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 데이터 로드 (streaming)\n",
+    "data_path = \"data/sft_train_llama.jsonl\"\n",
+    "dataset = load_dataset(\n",
+    "    \"json\",\n",
+    "    data_files=data_path,\n",
+    "    split=\"train\", \n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b47e061d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 학습 설정 - 메모리 최적화\n",
+    "sft_config = SFTConfig(\n",
+    "    output_dir=\"./qlora_output\",\n",
+    "    num_train_epochs=2,                 # ← 주석처리 또는 삭제\n",
+    "    per_device_train_batch_size=1,\n",
+    "    gradient_accumulation_steps=16,\n",
+    "    learning_rate=2e-4,\n",
+    "    bf16=True,\n",
+    "    logging_steps=10,\n",
+    "    save_steps=500,                       # ← epoch 대신 step 기준 저장\n",
+    "    optim=\"paged_adamw_8bit\",\n",
+    "    gradient_checkpointing=True,\n",
+    "    max_length=512,           \n",
+    "    dataset_text_field=\"text\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "5b82e6f5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# SFTTrainer로 학습\n",
+    "trainer = SFTTrainer(\n",
+    "    model=model,\n",
+    "    args=sft_config,\n",
+    "    train_dataset=dataset,\n",
+    "    processing_class=tokenizer,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "dd78a9cb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The tokenizer has new PAD/BOS/EOS tokens that differ from the model config and generation config. The model config and generation config were aligned accordingly, being updated with the tokenizer's values. Updated tokens: {'eos_token_id': 128001, 'bos_token_id': 128000, 'pad_token_id': 128001}.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='1058' max='1058' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [1058/1058 6:18:56, Epoch 2/2]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Step</th>\n",
+       "      <th>Training Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>2.525100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>20</td>\n",
+       "      <td>1.933300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>30</td>\n",
+       "      <td>1.800700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>40</td>\n",
+       "      <td>1.775700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>50</td>\n",
+       "      <td>1.773700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>60</td>\n",
+       "      <td>1.719500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>70</td>\n",
+       "      <td>1.715900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>80</td>\n",
+       "      <td>1.681300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>90</td>\n",
+       "      <td>1.671000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>100</td>\n",
+       "      <td>1.690100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>110</td>\n",
+       "      <td>1.712000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>120</td>\n",
+       "      <td>1.609300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>130</td>\n",
+       "      <td>1.614200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>140</td>\n",
+       "      <td>1.663300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>150</td>\n",
+       "      <td>1.624000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>160</td>\n",
+       "      <td>1.586000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>170</td>\n",
+       "      <td>1.614200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>180</td>\n",
+       "      <td>1.570300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>190</td>\n",
+       "      <td>1.609900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>200</td>\n",
+       "      <td>1.586800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>210</td>\n",
+       "      <td>1.523200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>220</td>\n",
+       "      <td>1.595500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>230</td>\n",
+       "      <td>1.604200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>240</td>\n",
+       "      <td>1.518400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>250</td>\n",
+       "      <td>1.551400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>260</td>\n",
+       "      <td>1.521200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>270</td>\n",
+       "      <td>1.585300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>280</td>\n",
+       "      <td>1.575400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>290</td>\n",
+       "      <td>1.507000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>300</td>\n",
+       "      <td>1.539600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>310</td>\n",
+       "      <td>1.489900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>320</td>\n",
+       "      <td>1.459300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>330</td>\n",
+       "      <td>1.555300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>340</td>\n",
+       "      <td>1.520400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>350</td>\n",
+       "      <td>1.549200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>360</td>\n",
+       "      <td>1.530700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>370</td>\n",
+       "      <td>1.532300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>380</td>\n",
+       "      <td>1.479400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>390</td>\n",
+       "      <td>1.469400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>400</td>\n",
+       "      <td>1.470800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>410</td>\n",
+       "      <td>1.505100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>420</td>\n",
+       "      <td>1.472500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>430</td>\n",
+       "      <td>1.477300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>440</td>\n",
+       "      <td>1.467300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>450</td>\n",
+       "      <td>1.459700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>460</td>\n",
+       "      <td>1.484500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>470</td>\n",
+       "      <td>1.499100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>480</td>\n",
+       "      <td>1.459900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>490</td>\n",
+       "      <td>1.430800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>500</td>\n",
+       "      <td>1.484700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>510</td>\n",
+       "      <td>1.459500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>520</td>\n",
+       "      <td>1.437000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>530</td>\n",
+       "      <td>1.433800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>540</td>\n",
+       "      <td>1.363500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>550</td>\n",
+       "      <td>1.348800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>560</td>\n",
+       "      <td>1.360600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>570</td>\n",
+       "      <td>1.307000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>580</td>\n",
+       "      <td>1.350000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>590</td>\n",
+       "      <td>1.436000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>600</td>\n",
+       "      <td>1.402600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>610</td>\n",
+       "      <td>1.369600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>620</td>\n",
+       "      <td>1.421000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>630</td>\n",
+       "      <td>1.377700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>640</td>\n",
+       "      <td>1.365100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>650</td>\n",
+       "      <td>1.326400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>660</td>\n",
+       "      <td>1.414200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>670</td>\n",
+       "      <td>1.400100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>680</td>\n",
+       "      <td>1.330200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>690</td>\n",
+       "      <td>1.380400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>700</td>\n",
+       "      <td>1.357300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>710</td>\n",
+       "      <td>1.387900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>720</td>\n",
+       "      <td>1.368100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>730</td>\n",
+       "      <td>1.312700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>740</td>\n",
+       "      <td>1.354500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>750</td>\n",
+       "      <td>1.343500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>760</td>\n",
+       "      <td>1.371200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>770</td>\n",
+       "      <td>1.292800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>780</td>\n",
+       "      <td>1.356000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>790</td>\n",
+       "      <td>1.353400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>800</td>\n",
+       "      <td>1.406300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>810</td>\n",
+       "      <td>1.376100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>820</td>\n",
+       "      <td>1.297200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>830</td>\n",
+       "      <td>1.405000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>840</td>\n",
+       "      <td>1.373500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>850</td>\n",
+       "      <td>1.338300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>860</td>\n",
+       "      <td>1.368300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>870</td>\n",
+       "      <td>1.398800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>880</td>\n",
+       "      <td>1.337500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>890</td>\n",
+       "      <td>1.367700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>900</td>\n",
+       "      <td>1.312600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>910</td>\n",
+       "      <td>1.353600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>920</td>\n",
+       "      <td>1.317400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>930</td>\n",
+       "      <td>1.348200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>940</td>\n",
+       "      <td>1.361800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>950</td>\n",
+       "      <td>1.290600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>960</td>\n",
+       "      <td>1.384400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>970</td>\n",
+       "      <td>1.290200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>980</td>\n",
+       "      <td>1.348800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>990</td>\n",
+       "      <td>1.330100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1000</td>\n",
+       "      <td>1.384700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1010</td>\n",
+       "      <td>1.368200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1020</td>\n",
+       "      <td>1.347500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1030</td>\n",
+       "      <td>1.332400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1040</td>\n",
+       "      <td>1.315800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1050</td>\n",
+       "      <td>1.348300</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "TrainOutput(global_step=1058, training_loss=1.4723652360119306, metrics={'train_runtime': 22771.7007, 'train_samples_per_second': 0.743, 'train_steps_per_second': 0.046, 'total_flos': 2.071327636721664e+17, 'train_loss': 1.4723652360119306, 'entropy': 1.4031210680802664, 'num_tokens': 4591590.0, 'mean_token_accuracy': 0.6802353163560232, 'epoch': 2.0})"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 학습 시작\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "94871386",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('./qlora_adapter/tokenizer_config.json',\n",
+       " './qlora_adapter/special_tokens_map.json',\n",
+       " './qlora_adapter/chat_template.jinja',\n",
+       " './qlora_adapter/tokenizer.json')"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 모델 저장 (LoRA 가중치만)\n",
+    "trainer.model.save_pretrained(\"./qlora_adapter\")\n",
+    "tokenizer.save_pretrained(\"./qlora_adapter\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1fbac3b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# dataset = dataset.shuffle(seed=42).select(range(1000))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (myenv)",
+   "language": "python",
+   "name": "myenv"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/train.py

@@ -0,0 +1,116 @@
+import torch
+import wandb
+from unsloth import FastLanguageModel, is_bfloat16_supported
+from trl import SFTTrainer
+from transformers import TrainingArguments
+from transformers.trainer_utils import get_last_checkpoint
+from datasets import load_dataset
+import os
+import shutil
+import time
+
+# ==========================================
+# [FINAL SCRIPT] Running on Terminal
+# ==========================================
+
+print(">>> [System] 스크립트 시작. 라이브러리 로딩 완료.")
+
+# 1. WandB 찌꺼기 폴더 강제 삭제
+if os.path.exists("wandb"):
+    try:
+        shutil.rmtree("wandb")
+        print(">>> [System] 기존 WandB 캐시 삭제 완료")
+    except:
+        pass
+
+# 2. 복구 모드 점검
+output_dir = "outputs_final"
+last_checkpoint = None
+
+if os.path.isdir(output_dir):
+    last_checkpoint = get_last_checkpoint(output_dir)
+    if last_checkpoint:
+        print(f">>> [Resume] 이전 학습 기록 발견: {last_checkpoint}")
+    else:
+        print(">>> [Start] 새로운 학습 시작")
+
+# 3. WandB 설정
+try:
+    wandb.finish()
+except:
+    pass
+
+unique_id = f"run_{int(time.time())}"
+
+wandb.init(
+    entity="hambur1203-project",
+    project="BiddinMate_Production_SFT",
+    name="Llama3-8B-Final-3Epochs",
+    id=unique_id,
+    resume="allow"
+)
+
+# 4. 모델 로드 (0번 GPU 강제 지정)
+print(">>> [Model] Llama-3 로드 중...")
+max_seq_length = 2048
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name = "beomi/Llama-3-Open-Ko-8B",
+    max_seq_length = max_seq_length,
+    dtype = None,
+    load_in_4bit = True,
+    device_map = {"": 0} # 핵심: GPU 0번 고정
+)
+
+# 5. LoRA 설정
+model = FastLanguageModel.get_peft_model(
+    model,
+    r = 16,
+    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
+                      "gate_proj", "up_proj", "down_proj",],
+    lora_alpha = 16,
+    lora_dropout = 0,
+    bias = "none",
+    use_gradient_checkpointing = "unsloth",
+    random_state = 3407,
+    use_rslora = False,
+    loftq_config = None,
+)
+
+# 6. 데이터셋 로드
+print(">>> [Data] 데이터셋 로드 중...")
+dataset = load_dataset("json", data_files="sft_train_llama.jsonl", split="train")
+
+# 7. 학습 설정
+trainer = SFTTrainer(
+    model = model,
+    tokenizer = tokenizer,
+    train_dataset = dataset,
+    dataset_text_field = "text",
+    max_seq_length = max_seq_length,
+    dataset_num_proc = 2,
+    packing = False,
+    args = TrainingArguments(
+        per_device_train_batch_size = 2,
+        gradient_accumulation_steps = 4,
+        num_train_epochs = 3,
+        warmup_steps = 100,
+        learning_rate = 2e-4,
+        report_to = "wandb",
+        run_name = "Llama3-8B-Final-3Epochs",
+        logging_steps = 1,
+        save_strategy = "epoch",
+        output_dir = output_dir,
+        fp16 = not is_bfloat16_supported(),
+        bf16 = is_bfloat16_supported(),
+        optim = "adamw_8bit",
+        weight_decay = 0.01,
+        seed = 3407,
+    ),
+)
+
+# 8. 실행
+print(">>> [Train] 학습 시작! (WandB를 확인하세요)")
+if last_checkpoint:
+    trainer.train(resume_from_checkpoint=True)
+else:
+    trainer.train()

project_setting.md

@@ -0,0 +1,295 @@
+## 🛠 사전 준비
+
+### 필수 설치 항목
+
+1. **Python 3.12.3**
+2. **pyenv** (Python 버전 관리)
+3. **Poetry** (의존성 관리)
+
+### 설치 방법
+
+#### 🪟 Windows
+
+```powershell
+# 1. pyenv-win 설치
+Invoke-WebRequest -UseBasicParsing -Uri "https://raw.githubusercontent.com/pyenv-win/pyenv-win/master/pyenv-win/install-pyenv-win.ps1" -OutFile "./install-pyenv-win.ps1"
+& "./install-pyenv-win.ps1"
+
+# PowerShell 재시작 후
+
+# 2. Python 3.12.3 설치
+pyenv install 3.12.3
+
+# 3. Poetry 설치
+(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
+```
+
+#### 🍎 Mac/Linux
+
+```bash
+# 1. pyenv 설치
+curl https://pyenv.run | bash
+
+# 환경 변수 설정 (zsh 기준)
+echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
+echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc
+echo 'eval "$(pyenv init -)"' >> ~/.zshrc
+source ~/.zshrc
+
+# 2. Python 3.12.3 설치
+pyenv install 3.12.3
+
+# 3. Poetry 설치
+curl -sSL https://install.python-poetry.org | python3 -
+```
+
+---
+
+## 🚀 환경 설정
+
+### 1. 저장소 클론
+
+#### 🪟 Windows
+```powershell
+git clone 
+cd Codeit-AI-1team-LLM-project
+```
+
+#### 🍎 Mac/Linux
+```bash
+git clone 
+cd Codeit-AI-1team-LLM-project
+```
+
+### 2. Python 버전 설정
+
+프로젝트 폴더에 `.python-version` 파일이 있으면 자동으로 Python 3.12.3을 사용합니다.
+
+#### 🪟 Windows
+```powershell
+# 확인
+python --version
+# Python 3.12.3이 아니면:
+pyenv local 3.12.3
+```
+
+#### 🍎 Mac/Linux
+```bash
+# 확인
+python --version
+# Python 3.12.3이 아니면:
+pyenv local 3.12.3
+```
+
+### 3. Poetry 설정
+
+#### 🪟 Windows
+```powershell
+# 가상환경을 프로젝트 내부에 생성
+python -m poetry config virtualenvs.in-project true
+```
+
+#### 🍎 Mac/Linux
+```bash
+poetry config virtualenvs.in-project true
+```
+
+---
+
+## 📦 의존성 설치
+
+`poetry.lock` 파일을 기준으로 정확히 동일한 버전의 패키지를 설치합니다.
+
+#### 🪟 Windows
+```powershell
+# Python 버전 지정
+python -m poetry env use 3.12.3
+
+# 의존성 설치
+python -m poetry install
+
+# 가상환경 활성화
+python -m poetry shell
+```
+
+#### 🍎 Mac/Linux
+```bash
+# Python 버전 지정
+poetry env use 3.12.3
+
+# 의존성 설치
+poetry install
+
+# 가상환경 활성화
+poetry shell
+```
+
+**설치 완료 확인:**
+
+프롬프트 앞에 `(.venv)`가 붙으면 성공! ✅
+
+```
+(.venv) PS C:\Codeit-AI-1team-LLM-project>  # Windows
+(codeit-ai-1team-llm-project-py3.12) user@computer:~/project$  # Mac/Linux
+```
+
+---
+
+## 🎯 프로젝트 실행
+
+### 기본 실행
+
+#### 🪟 Windows
+```powershell
+# 가상환경이 활성화된 상태에서
+python main.py
+```
+
+#### 🍎 Mac/Linux
+```bash
+# 가상환경이 활성화된 상태에서
+python main.py
+```
+
+### 가상환경 나가기
+
+#### 🪟 Windows & Mac/Linux
+```bash
+exit
+```
+
+---
+
+## 👥 개발 가이드
+
+### 일상적인 작업 흐름
+
+#### 🪟 Windows
+```powershell
+# 1. 프로젝트 폴더로 이동
+cd C:\Codeit-AI-1team-LLM-project
+
+# 2. 최신 코드 받기
+git pull
+
+# 3. 의존성 업데이트 (팀원이 패키지 추가한 경우)
+python -m poetry install
+
+# 4. 가상환경 활성화
+python -m poetry shell
+
+# 5. 개발 작업...
+
+# 6. 작업 종료
+exit
+```
+
+#### 🍎 Mac/Linux
+```bash
+# 1. 프로젝트 폴더로 이동
+cd ~/Codeit-AI-1team-LLM-project
+
+# 2. 최신 코드 받기
+git pull
+
+# 3. 의존성 업데이트 (팀원이 패키지 추가한 경우)
+poetry install
+
+# 4. 가상환경 활성화
+poetry shell
+
+# 5. 개발 작업...
+
+# 6. 작업 종료
+exit
+```
+
+### 새 패키지 추가
+
+#### 🪟 Windows
+```powershell
+# 패키지 추가
+python -m poetry add 
+
+# 예: requests 추가
+python -m poetry add requests
+
+# 개발 도구 추가
+python -m poetry add --group dev pytest
+
+# Git 커밋
+git add pyproject.toml poetry.lock
+git commit -m "Add "
+git push
+```
+
+#### 🍎 Mac/Linux
+```bash
+# 패키지 추가
+poetry add 
+
+# 예: requests 추가
+poetry add requests
+
+# 개발 도구 추가
+poetry add --group dev pytest
+
+# Git 커밋
+git add pyproject.toml poetry.lock
+git commit -m "Add "
+git push
+```
+
+---
+
+## 🐛 문제 해결
+
+### Python 버전이 3.12.3이 아니에요
+
+#### 🪟 Windows
+```powershell
+pyenv local 3.12.3
+python --version
+```
+
+#### 🍎 Mac/Linux
+```bash
+pyenv local 3.12.3
+python --version
+```
+
+### Poetry 명령어를 찾을 수 없어요
+
+#### 🪟 Windows
+```powershell
+# Poetry를 python 모듈로 실행
+python -m poetry --version
+
+# PATH 추가 (영구적)
+[Environment]::SetEnvironmentVariable("Path", [Environment]::GetEnvironmentVariable("Path", "User") + ";$env:APPDATA\Python\Scripts", "User")
+```
+
+#### 🍎 Mac/Linux
+```bash
+# PATH 추가
+export PATH="$HOME/.local/bin:$PATH"
+
+# 영구 적용
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
+source ~/.zshrc
+```
+
+### Import 에��가 나요
+
+```bash
+# 가상환경이 활성화되어 있는지 확인
+# 프롬프트에 (.venv)가 있어야 함
+
+# 없다면 다시 활성화
+poetry shell  # Mac/Linux
+python -m poetry shell  # Windows
+
+# 의존성 재설치
+poetry install  # Mac/Linux
+python -m poetry install  # Windows
+```

pyproject.toml

@@ -0,0 +1,68 @@
+[project]
+name = "codeit-ai-1team-llm-project"
+version = "0.1.0"
+description = "코드잇 중급 프로젝트 RAG 문서 요약 챗봇"
+authors = [
+    {name = "dong1203", email = "hambur1203@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.12.3"
+
+[tool.poetry]
+package-mode = false
+
+[tool.poetry.dependencies]
+python = "^3.12.3"
+# LangChain 생태계
+langchain = "^1.0.5"
+langchain-core = "^1.0.4"
+langchain-text-splitters = "^1.0.0"
+langchain-openai = "^1.0.2"
+
+# 문서 처리
+pypdf = "^6.2.0"
+olefile = "^0.47"
+
+# 데이터 처리
+pandas = "^2.3.3"
+numpy = "^2.3.0"
+
+# OpenAI API
+openai = "^2.7.2"
+
+# 벡터 DB
+chromadb = "^1.0.0"
+
+# 시각화
+streamlit = "^1.40.0"
+plotly = "^6.0.0"
+
+# 차원 축소
+scikit-learn = "^1.5.0"
+
+# 유틸리티
+tqdm = "^4.67.1"
+python-dotenv = "^1.0.0"
+langchain-chroma = "^1.0.0"
+openpyxl = "^3.1.5"
+wandb = "^0.23.0"
+ragas = "^0.3.9"
+langsmith = "^0.4.43"
+datasets = "^4.4.1"
+langchain-community = "^0.4.1"
+rapidfuzz = "^3.14.3"
+matplotlib = "^3.10.7"
+rank-bm25 = "^0.2.2"
+sentence-transformers = "^5.1.2"
+flagembedding = "^1.3.5"
+llama-cpp-python = "^0.3.16"
+huggingface-hub = ">=0.20.0"
+
+[tool.poetry.group.dev.dependencies]
+# 개발 도구 (선택사항)
+pytest = "^8.0.0"
+black = "^24.0.0"
+
+[build-system]
+requires = ["poetry-core>=2.0.0"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,52 @@
+# ===== LangChain 생태계 =====
+langchain>=0.1.0,<0.4.0
+langchain-core>=0.1.0,<0.4.0
+langchain-text-splitters>=0.0.1,<0.4.0
+langchain-openai>=0.0.5,<0.4.0
+langchain-chroma>=0.1.0,<0.4.0
+langchain-community>=0.0.20,<0.4.0
+
+# ===== OpenAI API =====
+openai>=1.0.0,<2.0.0
+
+# ===== 벡터 DB =====
+chromadb>=0.4.0,<0.6.0
+
+# ===== 문서 처리 =====
+pypdf>=3.0.0,<5.0.0
+olefile>=0.47
+
+# ===== 데이터 처리 =====
+pandas>=2.0.0,<3.0.0
+numpy>=1.24.0,<2.0.0
+openpyxl>=3.0.0,<4.0.0
+
+# ===== 검색 & 임베딩 =====
+rank-bm25>=0.2.2
+sentence-transformers>=2.2.0,<4.0.0
+FlagEmbedding>=1.2.0,<2.0.0
+rapidfuzz>=3.0.0,<4.0.0
+
+# ===== GGUF 모델 지원 (CPU 버전) =====
+llama-cpp-python>=0.2.0,<0.4.0
+
+# ===== Hugging Face Hub =====
+huggingface-hub>=0.20.0
+
+# ===== Streamlit UI =====
+streamlit>=1.28.0,<2.0.0
+plotly>=5.0.0,<6.0.0
+
+# ===== 머신러닝 유틸 =====
+scikit-learn>=1.3.0,<2.0.0
+matplotlib>=3.7.0,<4.0.0
+
+# ===== 유틸리티 =====
+tqdm>=4.65.0
+python-dotenv>=1.0.0
+
+# ===== 평가 & 모니터링 (선택) =====
+ragas>=0.1.0,<0.4.0
+langsmith>=0.1.0,<0.5.0
+wandb>=0.15.0,<0.17.0
+datasets>=2.14.0,<3.0.0

src/embedding/rag_data_processing.py

@@ -0,0 +1,230 @@
+import pandas as pd
+from langchain_chroma import Chroma
+from langchain_openai.embeddings import OpenAIEmbeddings
+import os
+from tqdm import tqdm
+import time
+
+from src.utils.config import RAGConfig
+
+
+class DataValidator:
+    """데이터 검증 및 정제"""
+
+    def __init__(self, config: RAGConfig):
+        self.config = config
+
+    def validate_and_clean(self, df: pd.DataFrame) -> pd.DataFrame:
+        """전체 검증 및 정제 파이프라인"""
+        df = self._check_required_columns(df)
+        df = self._remove_duplicates(df)
+        df = self._remove_nan(df)
+        df = self._filter_by_length(df)
+        df = self._clean_metadata(df)
+
+        return df
+
+    def _check_required_columns(self, df: pd.DataFrame) -> pd.DataFrame:
+        """필수 컬럼 확인"""
+        required = ['chunk_content', 'chunk_id']
+        missing = [col for col in required if col not in df.columns]
+
+        if missing:
+            raise ValueError(f"필수 컬럼 누락: {missing}")
+
+        return df
+
+    def _remove_duplicates(self, df: pd.DataFrame) -> pd.DataFrame:
+        """중복 ID 제거"""
+        return df.drop_duplicates(subset=['chunk_id'], keep='first')
+
+    def _remove_nan(self, df: pd.DataFrame) -> pd.DataFrame:
+        """NaN 값 제거"""
+        return df.dropna(subset=['chunk_content', 'chunk_id'])
+
+    def _filter_by_length(self, df: pd.DataFrame) -> pd.DataFrame:
+        """길이 기준 필터링"""
+        df['_temp_length'] = df['chunk_content'].str.len()
+
+        df = df[
+            (df['_temp_length'] >= self.config.MIN_CHUNK_LENGTH) &
+            (df['_temp_length'] <= self.config.MAX_CHUNK_LENGTH)
+        ]
+
+        return df.drop(columns=['_temp_length'])
+
+    def _clean_metadata(self, df: pd.DataFrame) -> pd.DataFrame:
+        """메타데이터 정제"""
+        # NaN을 빈 문자열로 변환
+        df = df.fillna('')
+
+        # 메타데이터 컬럼의 타입을 문자열로 변환
+        metadata_cols = [col for col in df.columns
+                        if col not in ['chunk_content', 'chunk_id']]
+
+        for col in metadata_cols:
+            df[col] = df[col].astype(str)
+
+        return df
+
+
+class ChromaDBBuilder:
+    """ChromaDB 벡터 데이터베이스 구축"""
+
+    def __init__(self, config: RAGConfig):
+        self.config = config
+        self.vectorstore = None
+        self.embeddings = None
+
+        self._initialize_embeddings()
+
+    def _initialize_embeddings(self):
+        """임베딩 모델 초기화"""
+        os.environ["OPENAI_API_KEY"] = self.config.OPENAI_API_KEY
+
+        self.embeddings = OpenAIEmbeddings(
+            model=self.config.EMBEDDING_MODEL_NAME
+        )
+
+    def build_from_dataframe(self, df: pd.DataFrame):
+        """DataFrame으로부터 벡터 DB 구축"""
+        documents, ids, metadatas = self._prepare_data(df)
+        self._validate_data_consistency(documents, ids, metadatas)
+        self._create_vectorstore()
+        self._add_documents_in_batches(documents, ids, metadatas)
+
+        return self.vectorstore
+
+    def _prepare_data(self, df: pd.DataFrame):
+        """ChromaDB용 데이터 준비"""
+        documents = df['chunk_content'].tolist()
+        ids = df['chunk_id'].tolist()
+
+        # 메타데이터 추출
+        metadata_cols = [col for col in df.columns
+                        if col not in ['chunk_content', 'chunk_id']]
+
+        metadatas = []
+        for _, row in df.iterrows():
+            metadata = {
+                col: row[col]
+                for col in metadata_cols
+                if row[col] and row[col] != 'nan' and row[col] != ''
+            }
+            metadatas.append(metadata)
+
+        return documents, ids, metadatas
+
+    def _validate_data_consistency(self, documents, ids, metadatas):
+        """데이터 일관성 검증"""
+        if not (len(documents) == len(ids) == len(metadatas)):
+            raise ValueError("데이터 길이 불일치")
+
+    def _create_vectorstore(self):
+        """빈 벡터스토어 생성"""
+        self.vectorstore = Chroma(
+            embedding_function=self.embeddings,
+            persist_directory=self.config.DB_DIRECTORY,
+            collection_name=self.config.COLLECTION_NAME
+        )
+
+    def _add_documents_in_batches(self, documents, ids, metadatas):
+        """배치 처리로 문서 추가"""
+        batch_size = self.config.BATCH_SIZE
+        total_batches = (len(documents) + batch_size - 1) // batch_size
+
+        for i in tqdm(range(0, len(documents), batch_size),
+                     desc="임베딩 및 저장",
+                     total=total_batches):
+
+            batch_docs = documents[i:i + batch_size]
+            batch_ids = ids[i:i + batch_size]
+            batch_metas = metadatas[i:i + batch_size]
+
+            self._add_batch_with_retry(batch_docs, batch_ids, batch_metas)
+            time.sleep(1)
+
+    def _add_batch_with_retry(self, docs, ids, metas):
+        """배치 추가 (실패 시 재시도)"""
+        batch_tokens = sum(len(doc) for doc in docs) / 4
+
+        if batch_tokens > self.config.MAX_TOKENS_PER_BATCH:
+            smaller_size = len(docs) // 2
+            for j in range(0, len(docs), smaller_size):
+                self.vectorstore.add_texts(
+                    texts=docs[j:j + smaller_size],
+                    metadatas=metas[j:j + smaller_size],
+                    ids=ids[j:j + smaller_size]
+                )
+                time.sleep(0.5)
+        else:
+            try:
+                self.vectorstore.add_texts(
+                    texts=docs,
+                    metadatas=metas,
+                    ids=ids
+                )
+            except Exception as e:
+                for j in range(0, len(docs), 10):
+                    self.vectorstore.add_texts(
+                        texts=docs[j:j + 10],
+                        metadatas=metas[j:j + 10],
+                        ids=ids[j:j + 10]
+                    )
+                    time.sleep(0.5)
+
+    def get_collection_count(self):
+        """저장된 문서 수 반환"""
+        if self.vectorstore:
+            return self.vectorstore._collection.count()
+        return 0
+
+    def search(self, query: str, k: int = 5):
+        """검색 수행"""
+        if not self.vectorstore:
+            raise ValueError("벡터스토어가 초기화되지 않았습니다")
+
+        return self.vectorstore.similarity_search_with_score(query, k=k)
+
+
+class RAGVectorDBPipeline:
+    """전체 RAG Vector DB 구축 파이프라인"""
+
+    def __init__(self, config: RAGConfig = None):
+        self.config = config or RAGConfig()
+        self.validator = DataValidator(self.config)
+        self.builder = ChromaDBBuilder(self.config)
+
+    def build(self):
+        """전체 파이프라인 실행"""
+        # 데이터 로드
+        df = pd.read_csv(self.config.RAG_INPUT_PATH)
+        print(f"원본 데이터: {len(df)}개 청크")
+
+        # 데이터 검증 및 정제
+        df_cleaned = self.validator.validate_and_clean(df)
+        print(f"정제 후 데이터: {len(df_cleaned)}개 청크")
+
+        # 벡터 DB 구축
+        vectorstore = self.builder.build_from_dataframe(df_cleaned)
+
+        # 결과 확인
+        count = self.builder.get_collection_count()
+        print(f"✅ ChromaDB 저장 완료: {count}개 문서")
+        print(f"저장 위치: {self.config.DB_DIRECTORY}")
+
+        return vectorstore
+
+    def test_search(self, query: str = "학사 정보 시스템", k: int = 3):
+        """검색 테스트"""
+        results = self.builder.search(query, k=k)
+
+        print(f"\n테스트 쿼리: '{query}'")
+        print(f"검색 결과: {len(results)}개\n")
+
+        for i, (doc, score) in enumerate(results, 1):
+            print(f"[{i}] 거리: {score:.4f}")
+            print(f"내용: {doc.page_content[:100]}...")
+            print(f"메타데이터: {doc.metadata}\n")
+
+        return results

src/evaluation/experiment_tracker.py

@@ -0,0 +1,427 @@
+# ===== experiment_tracker.py =====
+"""
+RAG 검색 시스템 실험 추적 및 비교 도구
+
+기능:
+1. 실험 결과 자동 저장
+2. 이전 실험과 비교
+3. 성능 차트 생성
+4. 최적 설정 추천
+"""
+
+import json
+import pandas as pd
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+import matplotlib.pyplot as plt
+import matplotlib
+matplotlib.use('Agg')  # 서버 환경 대응
+
+
+class ExperimentTracker:
+    """실험 추적 및 비교 클래스"""
+    
+    def __init__(self, log_dir: str = "src/evaluation/results/experiments"):
+        """
+        Args:
+            log_dir: 실험 로그 저장 디렉토리
+        """
+        self.log_dir = Path(log_dir)
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.log_file = self.log_dir / "experiments_log.json"
+        self.summary_file = self.log_dir / "experiments_summary.csv"
+        
+        # 로그 파일 초기화
+        if not self.log_file.exists():
+            self._save_log([])
+    
+    
+    # === 1. 실험 결과 저장 ===
+    
+    def log_experiment(
+        self,
+        experiment_name: str,
+        config: Dict[str, Any],
+        metrics: Dict[str, float],
+        langsmith_url: Optional[str] = None,
+        notes: str = ""
+    ) -> None:
+        """
+        실험 결과 저장
+        
+        Args:
+            experiment_name: 실험 이름 (예: "baseline", "embedding-small")
+            config: 설정 정보 (임베딩 모델, Top-K 등)
+            metrics: 평가 지표 (precision, recall 등)
+            langsmith_url: LangSmith 결과 URL
+            notes: 추가 메모
+        """
+        # 실험 데이터 구성
+        experiment_data = {
+            "timestamp": datetime.now().isoformat(),
+            "experiment_name": experiment_name,
+            "config": config,
+            "metrics": metrics,
+            "langsmith_url": langsmith_url,
+            "notes": notes
+        }
+        
+        # 기존 로그 로드
+        logs = self._load_log()
+        
+        # 새 실험 추가
+        logs.append(experiment_data)
+        
+        # 저장
+        self._save_log(logs)
+        self._update_summary()
+        
+        print(f"✅ 실험 '{experiment_name}' 저장 완료")
+        print(f"   Precision: {metrics.get('precision', 0):.4f}")
+        print(f"   Recall: {metrics.get('recall', 0):.4f}")
+    
+    
+    # === 2. 실험 비교 ===
+    
+    def compare_experiments(
+        self,
+        experiment_names: Optional[List[str]] = None,
+        top_n: int = 5
+    ) -> pd.DataFrame:
+        """
+        실험 결과 비교
+        
+        Args:
+            experiment_names: 비교할 실험 이름 리스트 (None이면 최근 실험)
+            top_n: experiment_names가 None일 때 최근 몇 개 비교할지
+            
+        Returns:
+            비교 결과 DataFrame
+        """
+        logs = self._load_log()
+        
+        if not logs:
+            print("⚠️ 저장된 실험이 없습니다")
+            return pd.DataFrame()
+        
+        # 비교할 실험 선택
+        if experiment_names is None:
+            # 최근 N개
+            selected_logs = logs[-top_n:]
+        else:
+            # 지정된 실험들
+            selected_logs = [
+                log for log in logs 
+                if log['experiment_name'] in experiment_names
+            ]
+        
+        if not selected_logs:
+            print("⚠️ 비교할 실험을 찾을 수 없습니다")
+            return pd.DataFrame()
+        
+        # DataFrame 생성
+        comparison_data = []
+        for log in selected_logs:
+            row = {
+                "실험명": log['experiment_name'],
+                "날짜": log['timestamp'][:10],
+                "임베딩": log['config'].get('embedding_model', 'N/A'),
+                "Top-K": log['config'].get('top_k', 'N/A'),
+                "Precision": log['metrics'].get('precision', 0),
+                "Recall": log['metrics'].get('recall', 0),
+                "F1": self._calculate_f1(
+                    log['metrics'].get('precision', 0),
+                    log['metrics'].get('recall', 0)
+                ),
+                "검색시간(초)": log['metrics'].get('avg_time', 0)
+            }
+            comparison_data.append(row)
+        
+        df = pd.DataFrame(comparison_data)
+        
+        # 출력
+        print("\n" + "="*80)
+        print("📊 실험 비교 결과")
+        print("="*80)
+        print(df.to_string(index=False))
+        print("="*80)
+        
+        return df
+    
+    
+    def show_improvement(self, baseline_name: str, current_name: str) -> None:
+        """
+        Baseline 대비 개선 효과 출력
+        
+        Args:
+            baseline_name: 기준 실험 이름
+            current_name: 비교할 실험 이름
+        """
+        logs = self._load_log()
+        
+        # 실험 찾기
+        baseline = next((log for log in logs if log['experiment_name'] == baseline_name), None)
+        current = next((log for log in logs if log['experiment_name'] == current_name), None)
+        
+        if not baseline or not current:
+            print("⚠️ 실험을 찾을 수 없습니다")
+            return
+        
+        # 개선율 계산
+        baseline_precision = baseline['metrics'].get('precision', 0)
+        baseline_recall = baseline['metrics'].get('recall', 0)
+        
+        current_precision = current['metrics'].get('precision', 0)
+        current_recall = current['metrics'].get('recall', 0)
+        
+        precision_improvement = (current_precision - baseline_precision) / baseline_precision * 100 if baseline_precision > 0 else 0
+        recall_improvement = (current_recall - baseline_recall) / baseline_recall * 100 if baseline_recall > 0 else 0
+        
+        # 출력
+        print("\n" + "="*80)
+        print(f"📈 개선 효과: {baseline_name} → {current_name}")
+        print("="*80)
+        print(f"\nPrecision:")
+        print(f"  {baseline_name}: {baseline_precision:.4f}")
+        print(f"  {current_name}: {current_precision:.4f}")
+        print(f"  개선율: {precision_improvement:+.2f}% {'✅' if precision_improvement > 0 else '❌'}")
+        
+        print(f"\nRecall:")
+        print(f"  {baseline_name}: {baseline_recall:.4f}")
+        print(f"  {current_name}: {current_recall:.4f}")
+        print(f"  개선율: {recall_improvement:+.2f}% {'✅' if recall_improvement > 0 else '❌'}")
+        
+        print("\n" + "="*80)
+    
+    
+    # === 3. 시각화 ===
+    
+    def plot_metrics(
+        self,
+        experiment_names: Optional[List[str]] = None,
+        save_path: Optional[str] = None
+    ) -> None:
+        """
+        실험 결과 차트 생성
+        
+        Args:
+            experiment_names: 차트에 포함할 실험 (None이면 전체)
+            save_path: 차트 저장 경로 (None이면 화면 출력)
+        """
+        logs = self._load_log()
+        
+        if not logs:
+            print("⚠️ 저장된 실험이 없습니다")
+            return
+        
+        # 실험 선택
+        if experiment_names is not None:
+            logs = [log for log in logs if log['experiment_name'] in experiment_names]
+        
+        if not logs:
+            print("⚠️ 차트를 그릴 실험이 없습니다")
+            return
+        
+        # 데이터 준비
+        names = [log['experiment_name'] for log in logs]
+        precisions = [log['metrics'].get('precision', 0) for log in logs]
+        recalls = [log['metrics'].get('recall', 0) for log in logs]
+        
+        # 차트 생성
+        fig, ax = plt.subplots(figsize=(12, 6))
+        
+        x = range(len(names))
+        width = 0.35
+        
+        ax.bar([i - width/2 for i in x], precisions, width, label='Precision', alpha=0.8)
+        ax.bar([i + width/2 for i in x], recalls, width, label='Recall', alpha=0.8)
+        
+        ax.set_xlabel('실험')
+        ax.set_ylabel('점수')
+        ax.set_title('실험별 성능 비교')
+        ax.set_xticks(x)
+        ax.set_xticklabels(names, rotation=45, ha='right')
+        ax.legend()
+        ax.grid(axis='y', alpha=0.3)
+        
+        plt.tight_layout()
+        
+        # 저장 또는 출력
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            print(f"✅ 차트 저장: {save_path}")
+        else:
+            default_path = self.log_dir / "comparison_chart.png"
+            plt.savefig(default_path, dpi=300, bbox_inches='tight')
+            print(f"✅ 차트 저장: {default_path}")
+        
+        plt.close()
+    
+    
+    # === 4. 최적 설정 추천 ===
+    
+    def recommend_best(self, metric: str = "f1") -> Dict[str, Any]:
+        """
+        최적 설정 추천
+        
+        Args:
+            metric: 기준 지표 ("precision", "recall", "f1")
+            
+        Returns:
+            최적 실험 정보
+        """
+        logs = self._load_log()
+        
+        if not logs:
+            print("⚠️ 저장된 실험이 없습니다")
+            return {}
+        
+        # F1 점수 계산
+        for log in logs:
+            if 'f1' not in log['metrics']:
+                p = log['metrics'].get('precision', 0)
+                r = log['metrics'].get('recall', 0)
+                log['metrics']['f1'] = self._calculate_f1(p, r)
+        
+        # 최적 실험 찾기
+        best = max(logs, key=lambda x: x['metrics'].get(metric, 0))
+        
+        print("\n" + "="*80)
+        print(f"🏆 최적 설정 ({metric.upper()} 기준)")
+        print("="*80)
+        print(f"실험명: {best['experiment_name']}")
+        print(f"날짜: {best['timestamp'][:10]}")
+        print(f"\n설정:")
+        for key, value in best['config'].items():
+            print(f"  {key}: {value}")
+        print(f"\n성능:")
+        print(f"  Precision: {best['metrics'].get('precision', 0):.4f}")
+        print(f"  Recall: {best['metrics'].get('recall', 0):.4f}")
+        print(f"  F1: {best['metrics'].get('f1', 0):.4f}")
+        print("="*80)
+        
+        return best
+    
+    
+    # === 5. 유틸리티 ===
+    
+    def list_experiments(self) -> None:
+        """저장된 실험 목록 출력"""
+        logs = self._load_log()
+        
+        if not logs:
+            print("⚠️ 저장된 실험이 없습니다")
+            return
+        
+        print("\n" + "="*80)
+        print("📋 저장된 실험 목록")
+        print("="*80)
+        
+        for i, log in enumerate(logs, 1):
+            print(f"\n{i}. {log['experiment_name']}")
+            print(f"   날짜: {log['timestamp'][:10]}")
+            print(f"   Precision: {log['metrics'].get('precision', 0):.4f}")
+            print(f"   Recall: {log['metrics'].get('recall', 0):.4f}")
+        
+        print("="*80)
+    
+    
+    def clear_experiments(self) -> None:
+        """모든 실험 로그 삭제 (주의!)"""
+        confirm = input("⚠️ 모든 실험 로그를 삭제하시겠습니까? (yes/no): ")
+        if confirm.lower() == 'yes':
+            self._save_log([])
+            self._update_summary()
+            print("✅ 모든 실험 로그 삭제 완료")
+        else:
+            print("❌ 취소됨")
+    
+    
+    # === 내부 함수 ===
+    
+    def _load_log(self) -> List[Dict]:
+        """로그 파일 로드"""
+        if not self.log_file.exists():
+            return []
+        
+        with open(self.log_file, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    
+    
+    def _save_log(self, logs: List[Dict]) -> None:
+        """로그 파일 저장"""
+        with open(self.log_file, 'w', encoding='utf-8') as f:
+            json.dump(logs, f, indent=2, ensure_ascii=False)
+    
+    
+    def _update_summary(self) -> None:
+        """요약 CSV 업데이트"""
+        logs = self._load_log()
+        
+        if not logs:
+            return
+        
+        summary_data = []
+        for log in logs:
+            row = {
+                "timestamp": log['timestamp'],
+                "experiment_name": log['experiment_name'],
+                "embedding_model": log['config'].get('embedding_model', 'N/A'),
+                "top_k": log['config'].get('top_k', 'N/A'),
+                "precision": log['metrics'].get('precision', 0),
+                "recall": log['metrics'].get('recall', 0),
+                "f1": self._calculate_f1(
+                    log['metrics'].get('precision', 0),
+                    log['metrics'].get('recall', 0)
+                ),
+                "avg_time": log['metrics'].get('avg_time', 0)
+            }
+            summary_data.append(row)
+        
+        df = pd.DataFrame(summary_data)
+        df.to_csv(self.summary_file, index=False, encoding='utf-8-sig')
+    
+    
+    @staticmethod
+    def _calculate_f1(precision: float, recall: float) -> float:
+        """F1 점수 계산"""
+        if precision + recall == 0:
+            return 0
+        return 2 * (precision * recall) / (precision + recall)
+
+
+# ===== 사용 예시 =====
+
+if __name__ == "__main__":
+    # Tracker 초기화
+    tracker = ExperimentTracker()
+    
+    # 예시 1: 실험 결과 저장
+    tracker.log_experiment(
+        experiment_name="baseline",
+        config={
+            "embedding_model": "text-embedding-3-small",
+            "top_k": 5,
+            "chunk_size": 1000
+        },
+        metrics={
+            "precision": 0.30,
+            "recall": 0.65,
+            "avg_time": 0.41
+        },
+        notes="초기 baseline 실험"
+    )
+    
+    # 예시 2: 실험 비교
+    tracker.compare_experiments()
+    
+    # 예시 3: 개선 효과 확인
+    # tracker.show_improvement("baseline", "embedding-small")
+    
+    # 예시 4: 차트 생성
+    # tracker.plot_metrics()
+    
+    # 예시 5: 최적 설정 추천
+    # tracker.recommend_best(metric="f1")

src/evaluation/run_experiment.py

@@ -0,0 +1,535 @@
+"""
+RAG 검색 시스템 평가 도구
+- LangSmith Experiment 실행
+- Context Precision/Recall 평가
+- 실험 추적 및 비교
+
+사용법:
+    python run_experiment.py              # 대화형 메뉴
+    python run_experiment.py --run        # 실험 실행
+    python run_experiment.py --compare    # 실험 비교
+"""
+
+import os
+import re
+import sys
+import argparse
+from pathlib import Path
+from typing import Dict, List, Any
+from langsmith import Client, evaluate
+from dotenv import load_dotenv
+
+# 프로젝트 경로 추가
+project_root = Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.retriever.retriever import RAGRetriever
+from src.utils.config import RAGConfig
+from src.evaluation.experiment_tracker import ExperimentTracker
+
+
+# === 환경 설정 ===
+load_dotenv()
+os.environ["LANGCHAIN_PROJECT"] = "RAG-Retriever-Eval"
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+
+
+# === 전역 변수 ===
+retriever = None
+
+
+# ============================================================
+# Evaluator 함수들
+# ============================================================
+
+def normalize_text(text: str) -> str:
+    """텍스트 정규화"""
+    # 소문자 변환
+    normalized = text.lower()
+    
+    # 특수문자 제거
+    normalized = re.sub(r'[\r\n\t]+', ' ', normalized)
+    
+    # 연속 공백 하나로
+    normalized = ' '.join(normalized.split())
+    
+    return normalized.strip()
+
+
+def is_matching_context(retrieved_text: str, ground_truth_text: str, threshold: float = 0.5) -> bool:
+    """두 문서가 같은 문서인지 판단"""
+    normalized_retrieved = normalize_text(retrieved_text)
+    normalized_truth = normalize_text(ground_truth_text)
+    
+    # 완전 포함 체크
+    if normalized_truth in normalized_retrieved:
+        return True
+    
+    if normalized_retrieved in normalized_truth:
+        return True
+    
+    # 단어 커버리지 체크
+    truth_words = set(normalized_truth.split())
+    retrieved_words = set(normalized_retrieved.split())
+    
+    if len(truth_words) == 0:
+        return False
+    
+    matched_words = truth_words & retrieved_words
+    coverage = len(matched_words) / len(truth_words)
+    
+    return coverage >= threshold
+
+
+def count_matching_contexts(
+    retrieved_contexts: List[str],
+    ground_truth_contexts: List[str],
+    threshold: float = 0.5
+) -> int:
+    """매칭되는 문서 개수 계산"""
+    matched_count = 0
+    
+    for retrieved in retrieved_contexts:
+        for truth in ground_truth_contexts:
+            if is_matching_context(retrieved, truth, threshold):
+                matched_count += 1
+                break
+    
+    return matched_count
+
+
+def context_precision_evaluator(run: Any, example: Any) -> Dict[str, float]:
+    """Context Precision 평가"""
+    try:
+        # 검색 결과 추출
+        if isinstance(run.outputs, dict):
+            retrieved_results = run.outputs.get('output', [])
+        else:
+            retrieved_results = run.outputs
+        
+        # 텍스트만 추출
+        retrieved_contexts = []
+        for result in retrieved_results:
+            if isinstance(result, dict):
+                text = result.get('content', '')
+                if text:
+                    retrieved_contexts.append(text)
+        
+        # 정답 추출
+        ground_truth_contexts = example.outputs.get('ground_truth_contexts', [])
+        
+        # 검증
+        if len(retrieved_contexts) == 0:
+            return {"key": "context_precision", "score": 0.0, "comment": "검색 결과 없음"}
+        
+        if len(ground_truth_contexts) == 0:
+            return {"key": "context_precision", "score": 0.0, "comment": "정답 없음"}
+        
+        # 매칭 개수 계산
+        matched_count = count_matching_contexts(
+            retrieved_contexts,
+            ground_truth_contexts,
+            threshold=0.5
+        )
+        
+        # Precision 계산
+        precision = matched_count / len(retrieved_contexts)
+        
+        return {
+            "key": "context_precision",
+            "score": precision,
+            "comment": f"매칭: {matched_count}/{len(retrieved_contexts)}"
+        }
+        
+    except Exception as e:
+        print(f"Context Precision 계산 오류: {e}")
+        import traceback
+        traceback.print_exc()
+        return {"key": "context_precision", "score": 0.0, "comment": f"오류: {str(e)}"}
+
+
+def context_recall_evaluator(run: Any, example: Any) -> Dict[str, float]:
+    """Context Recall 평가"""
+    try:
+        # 검색 결과 추출
+        if isinstance(run.outputs, dict):
+            retrieved_results = run.outputs.get('output', [])
+        else:
+            retrieved_results = run.outputs
+        
+        retrieved_contexts = []
+        for result in retrieved_results:
+            if isinstance(result, dict):
+                text = result.get('content', '')
+                if text:
+                    retrieved_contexts.append(text)
+        
+        # 정답 추출
+        ground_truth_contexts = example.outputs.get('ground_truth_contexts', [])
+        
+        # 검증
+        if len(ground_truth_contexts) == 0:
+            return {"key": "context_recall", "score": 0.0, "comment": "정답 없음"}
+        
+        if len(retrieved_contexts) == 0:
+            return {"key": "context_recall", "score": 0.0, "comment": "검색 결과 없음"}
+        
+        # 매칭 개수 계산
+        matched_count = 0
+        for truth in ground_truth_contexts:
+            for retrieved in retrieved_contexts:
+                if is_matching_context(retrieved, truth, threshold=0.5):
+                    matched_count += 1
+                    break
+        
+        # Recall 계산
+        recall = matched_count / len(ground_truth_contexts)
+        
+        return {
+            "key": "context_recall",
+            "score": recall,
+            "comment": f"발견: {matched_count}/{len(ground_truth_contexts)}"
+        }
+        
+    except Exception as e:
+        print(f"Context Recall 계산 오류: {e}")
+        import traceback
+        traceback.print_exc()
+        return {"key": "context_recall", "score": 0.0, "comment": f"오류: {str(e)}"}
+
+
+def retrieval_time_evaluator(run: Any, example: Any) -> Dict[str, float]:
+    """검색 시간 측정"""
+    try:
+        latency = run.execution_time
+        return {
+            "key": "retrieval_time",
+            "score": latency,
+            "comment": f"{latency:.3f}초"
+        }
+    except Exception as e:
+        return {"key": "retrieval_time", "score": 0.0, "comment": "시간 측정 실패"}
+
+
+# ============================================================
+# Target 함수
+# ============================================================
+
+def retriever_target(inputs: dict) -> dict:
+    """LangSmith Experiment용 검색 함수"""
+    question = inputs.get("question", "")
+    
+    if not question:
+        return {"output": []}
+    
+    # 하이브리드 검색 + Re-ranker 실행
+    results = retriever.search_with_mode(
+        query=question, 
+        top_k=None, 
+        mode="hybrid_rerank", 
+        alpha=0.5
+    )
+    
+    return {"output": results}
+
+
+# ============================================================
+# 실험 실행
+# ============================================================
+
+def run_experiment(
+    experiment_name: str,
+    config: dict,
+    dataset_name: str = "RAG-Retriever-TestSet-v1",
+    notes: str = ""
+) -> dict:
+    """
+    실험 실행 및 자동 추적
+    
+    Args:
+        experiment_name: 실험 이름
+        config: 실험 설정
+        dataset_name: Dataset 이름
+        notes: 메모
+        
+    Returns:
+        실험 결과
+    """
+    global retriever
+    
+    print("\n" + "="*80)
+    print(f"🚀 실험 시작: {experiment_name}")
+    print("="*80)
+    
+    # 1. 검색기 초기화
+    print("\n🔧 검색기 초기화...")
+    rag_config = RAGConfig()
+    
+    # Config 적용
+    if 'embedding_model' in config:
+        rag_config.EMBEDDING_MODEL_NAME = config['embedding_model']
+    if 'top_k' in config:
+        rag_config.DEFAULT_TOP_K = config['top_k']
+    
+    retriever = RAGRetriever(config=rag_config)
+    
+    print(f"✅ 설정 완료:")
+    print(f"   임베딩 모델: {rag_config.EMBEDDING_MODEL_NAME}")
+    print(f"   Top-K: {rag_config.DEFAULT_TOP_K}")
+    
+    # 2. Evaluators 설정
+    evaluators_list = [
+        context_precision_evaluator,
+        context_recall_evaluator,
+    ]
+    
+    # 3. LangSmith Client 초기화
+    client = Client()
+    
+    # 4. Experiment 실행
+    print(f"\n⏳ Experiment 실행 중...")
+    
+    try:
+        results = evaluate(
+            retriever_target,
+            data=dataset_name,
+            evaluators=evaluators_list,
+            experiment_prefix=experiment_name,
+            max_concurrency=1,
+        )
+        
+        print(f"\n✅ Experiment 완료!")
+        
+        # 5. 결과 추출
+        df = results.to_pandas()
+        
+        metrics = {
+            "precision": df["feedback.context_precision"].mean(),
+            "recall": df["feedback.context_recall"].mean(),
+            "avg_time": df["execution_time"].mean(),
+        }
+        
+        # 6. 자동 추적 저장
+        tracker = ExperimentTracker()
+        
+        langsmith_url = "https://smith.langchain.com/"
+        
+        tracker.log_experiment(
+            experiment_name=experiment_name,
+            config=config,
+            metrics=metrics,
+            langsmith_url=langsmith_url,
+            notes=notes
+        )
+        
+        # 7. 결과 출력
+        print("\n" + "="*80)
+        print("📊 실험 결과")
+        print("="*80)
+        print(f"Precision: {metrics['precision']:.4f}")
+        print(f"Recall: {metrics['recall']:.4f}")
+        
+        f1 = 0
+        if (metrics['precision'] + metrics['recall']) > 0:
+            f1 = 2 * metrics['precision'] * metrics['recall'] / (metrics['precision'] + metrics['recall'])
+        print(f"F1: {f1:.4f}")
+        print(f"평균 검색 시간: {metrics['avg_time']:.3f}초")
+        print("="*80)
+        
+        return results
+        
+    except Exception as e:
+        print(f"\n❌ 실험 실패: {e}")
+        import traceback
+        traceback.print_exc()
+        raise
+
+
+# ============================================================
+# 대화형 메뉴
+# ============================================================
+
+def interactive_run():
+    """대화형 실험 실행"""
+    print("\n" + "="*80)
+    print("🧪 RAG 검색 시스템 성능 실험")
+    print("="*80)
+    
+    # 실험 설정 입력
+    print("\n실험 설정을 입력하세요:")
+    
+    experiment_name = input("실험 이름 (예: baseline, hybrid-rerank): ").strip()
+    if not experiment_name:
+        experiment_name = "experiment"
+    
+    embedding_model = input("임베딩 모델 (엔터: text-embedding-3-small): ").strip()
+    if not embedding_model:
+        embedding_model = "text-embedding-3-small"
+    
+    top_k_input = input("Top-K (엔터: 10): ").strip()
+    top_k = int(top_k_input) if top_k_input else 10
+    
+    notes = input("메모 (선택사항): ").strip()
+    
+    # 설정 구성
+    config = {
+        "embedding_model": embedding_model,
+        "top_k": top_k,
+    }
+    
+    # 확인
+    print("\n" + "="*80)
+    print("📋 실험 정보 확인")
+    print("="*80)
+    print(f"실험 이름: {experiment_name}")
+    print(f"임베딩 모델: {embedding_model}")
+    print(f"Top-K: {top_k}")
+    if notes:
+        print(f"메모: {notes}")
+    print("="*80)
+    
+    confirm = input("\n실험을 시작하시겠습니까? (y/n): ").strip().lower()
+    if confirm != 'y':
+        print("❌ 취소됨")
+        return
+    
+    # 실험 실행
+    run_experiment(
+        experiment_name=experiment_name,
+        config=config,
+        notes=notes
+    )
+
+
+def interactive_compare():
+    """대화형 실험 비교"""
+    tracker = ExperimentTracker()
+    
+    print("\n" + "="*80)
+    print("🔍 실험 비교 도구")
+    print("="*80)
+    
+    while True:
+        print("\n메뉴:")
+        print("  1. 모든 실험 목록 보기")
+        print("  2. 최근 실험 비교 (최근 5개)")
+        print("  3. 특정 실험 비교")
+        print("  4. 개선 효과 확인")
+        print("  5. 차트 생성")
+        print("  6. 최적 설정 추천")
+        print("  0. 종료")
+        
+        choice = input("\n선택: ").strip()
+        
+        if choice == "1":
+            tracker.list_experiments()
+        
+        elif choice == "2":
+            tracker.compare_experiments(top_n=5)
+        
+        elif choice == "3":
+            names = input("실험 이름들 (쉼표로 구분): ").strip()
+            if names:
+                experiment_names = [n.strip() for n in names.split(',')]
+                tracker.compare_experiments(experiment_names=experiment_names)
+        
+        elif choice == "4":
+            baseline = input("Baseline 실험 이름: ").strip()
+            current = input("비교할 실험 이름: ").strip()
+            
+            if baseline and current:
+                tracker.show_improvement(baseline, current)
+        
+        elif choice == "5":
+            names_input = input("실험 이름들 (쉼표로 구분, 엔터: 전체): ").strip()
+            
+            if names_input:
+                experiment_names = [n.strip() for n in names_input.split(',')]
+            else:
+                experiment_names = None
+            
+            tracker.plot_metrics(experiment_names=experiment_names)
+        
+        elif choice == "6":
+            metric = input("기준 지표 (precision/recall/f1, 엔터: f1): ").strip()
+            if not metric:
+                metric = "f1"
+            
+            tracker.recommend_best(metric=metric)
+        
+        elif choice == "0":
+            print("👋 종료합니다")
+            break
+        
+        else:
+            print("❌ 잘못된 선택입니다")
+
+
+def main_menu():
+    """메인 메뉴"""
+    print("\n" + "="*80)
+    print("🔬 RAG 평가 시스템")
+    print("="*80)
+    
+    while True:
+        print("\n메뉴:")
+        print("  1. 실험 실행")
+        print("  2. 실험 비교")
+        print("  0. 종료")
+        
+        choice = input("\n선택: ").strip()
+        
+        if choice == "1":
+            interactive_run()
+        
+        elif choice == "2":
+            interactive_compare()
+        
+        elif choice == "0":
+            print("👋 종료합니다")
+            break
+        
+        else:
+            print("❌ 잘못된 선택입니다")
+
+
+# ============================================================
+# 메인 실행
+# ============================================================
+
+def main():
+    """메인 실행"""
+    parser = argparse.ArgumentParser(description='RAG 평가 시스���')
+    
+    parser.add_argument(
+        '--run',
+        action='store_true',
+        help='실험 실행 모드'
+    )
+    
+    parser.add_argument(
+        '--compare',
+        action='store_true',
+        help='실험 비교 모드'
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        if args.run:
+            interactive_run()
+        elif args.compare:
+            interactive_compare()
+        else:
+            main_menu()
+            
+    except KeyboardInterrupt:
+        print("\n\n⚠️ 중단됨")
+    except Exception as e:
+        print(f"\n❌ 오류: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

src/generator/generator.py

@@ -0,0 +1,335 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough, RunnableLambda
+from langchain_core.messages import HumanMessage, AIMessage
+from langsmith import traceable
+import time
+from typing import List, Dict
+
+from src.utils.config import RAGConfig
+from src.retriever.retriever import RAGRetriever
+
+
+class RAGPipeline:
+    """대화형 RAG 파이프라인 - LangChain Chain 기반"""
+
+    def __init__(self, config: RAGConfig = None, model: str = None, top_k: int = None):
+        """초기화"""
+        self.config = config or RAGConfig()
+        self.model = model or self.config.LLM_MODEL_NAME
+        self.top_k = top_k or self.config.DEFAULT_TOP_K
+        
+        # 검색 설정
+        self.search_mode = self.config.DEFAULT_SEARCH_MODE
+        self.alpha = self.config.DEFAULT_ALPHA
+
+        # LLM 초기화 (LangChain ChatOpenAI)
+        self.llm = ChatOpenAI(
+            model=self.model,
+            openai_api_key=self.config.OPENAI_API_KEY,
+            timeout=60.0,
+            max_retries=3
+        )
+
+        # Retriever 초기화
+        self.retriever = RAGRetriever(config=self.config)
+        
+        # 대화 히스토리
+        self.chat_history: List[Dict] = []
+        
+        # 마지막 검색 결과 저장 (sources 반환용)
+        self._last_retrieved_docs = []
+
+        # 프롬프트 템플릿 (대화 히스토리 포함)
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", """당신은 공공입찰 RFP를 분석하는 입찰메이트 사내 분석가입니다. 제공된 컨텍스트만으로 요구사항·예산·대상 기관·제출 방식 등을 구조화해 의사결정을 지원하세요.
+
+            # 규칙
+            - 답변은 한국어로 작성합니다.
+            - 컨텍스트 밖 내용을 추측하지 않습니다.
+            - 정보가 없으면 "문서에서 해당 정보를 찾을 수 없습니다."라고 밝힙니다.
+            - 여러 문서를 비교할 때는 문서별 차이를 표 또는 목록으로 정리합니다.
+            - 숫자에는 가능한 단위를 포함합니다.
+            - 직전 대화 맥락을 반영합니다.
+
+            # 답변 형식
+            1. 한 줄 요약: 질문 핵심을 한두 문장으로 작성합니다.
+            2. 상세 답변: [요구사항], [대상 기관], [예산], [제출 형식/방법], [평가 기준] 등 문서에서 확인된 항목만 정리합니다.
+            3. 근거 정보: 위 답변의 근거가 된 문장이나 문단을 요약합니다.
+            4. 부족한 정보: 문서에서 찾을 수 없는 항목은 "문서에서 확인 불가"로 표기합니다."""),
+                        
+                        # 대화 히스토리
+                        MessagesPlaceholder(variable_name="chat_history"),
+                        
+                        # 현재 질문과 컨텍스트
+                        ("user", """# 컨텍스트
+            {context}
+
+            # 질문
+            {question}
+
+            위 규칙에 따라 답변하세요.""")
+        ])
+
+        # Chain 구성
+        self.chain = (
+            {
+                "context": RunnableLambda(self._retrieve_and_format),
+                "question": RunnablePassthrough(),
+                "chat_history": RunnableLambda(lambda x: self._get_chat_history())
+            }
+            | self.prompt
+            | self.llm
+            | StrOutputParser()
+        )
+
+        print(f"✅ RAG 파이프라인 초기화 완료")
+        print(f"   - 모델: {self.model}")
+        print(f"   - 기본 top_k: {self.top_k}")
+        print(f"   - 검색 모드: {self.search_mode}")
+
+    def _get_chat_history(self) -> List:
+        """대화 히스토리를 LangChain 메시지 형식으로 변환"""
+        messages = []
+        for msg in self.chat_history:
+            if msg["role"] == "user":
+                messages.append(HumanMessage(content=msg["content"]))
+            else:
+                messages.append(AIMessage(content=msg["content"]))
+        return messages
+
+    def _retrieve_and_format(self, query: str) -> str:
+        """검색 수행 및 컨텍스트 포맷팅"""
+        # 검색 모드에 따라 문서 검색
+        if self.search_mode == "embedding":
+            docs = self.retriever.search(query, top_k=self.top_k)
+        elif self.search_mode == "hybrid":
+            docs = self.retriever.hybrid_search(query, top_k=self.top_k, alpha=self.alpha)
+        elif self.search_mode == "hybrid_rerank":
+            docs = self.retriever.hybrid_search_with_rerank(
+                query, top_k=self.top_k, alpha=self.alpha
+            )
+        else:
+            docs = self.retriever.search(query, top_k=self.top_k)
+        
+        # 마지막 검색 결과 저장
+        self._last_retrieved_docs = docs
+        
+        # 컨텍스트 포맷팅
+        return self._format_context(docs)
+
+    def _format_context(self, retrieved_docs: list) -> str:
+        """검색된 문서를 컨텍스트로 변환"""
+        if not retrieved_docs:
+            return "관련 문서를 찾을 수 없습니다."
+        
+        context_parts = []
+        for i, doc in enumerate(retrieved_docs, 1):
+            context_parts.append(f"[문서 {i}]\n{doc['content']}\n")
+        return "\n".join(context_parts)
+
+    def _format_sources(self, retrieved_docs: list) -> list:
+        """검색된 문서를 sources 형식으로 변환"""
+        sources = []
+        for doc in retrieved_docs:
+            source_info = {
+                'content': doc['content'],
+                'metadata': doc['metadata'],
+                'filename': doc.get('filename', 'N/A'),
+                'organization': doc.get('organization', 'N/A')
+            }
+            
+            # 검색 모드에 따라 점수 필드가 다름
+            if 'rerank_score' in doc:
+                source_info['score'] = doc['rerank_score']
+                source_info['score_type'] = 'rerank'
+            elif 'hybrid_score' in doc:
+                source_info['score'] = doc['hybrid_score']
+                source_info['score_type'] = 'hybrid'
+            elif 'relevance_score' in doc:
+                source_info['score'] = doc['relevance_score']
+                source_info['score_type'] = 'embedding'
+            else:
+                source_info['score'] = 0
+                source_info['score_type'] = 'unknown'
+            
+            sources.append(source_info)
+        return sources
+
+    @traceable(
+        name="RAG_Generate_Answer",
+        metadata={"component": "generator", "version": "2.0"}
+    )
+    def generate_answer(
+        self, 
+        query: str, 
+        top_k: int = None,
+        search_mode: str = None,
+        alpha: float = None
+    ) -> dict:
+        """
+        답변 생성 (Chain 기반)
+        
+        Args:
+            query: 질문
+            top_k: 검색할 문서 수
+            search_mode: 검색 모드 ("embedding", "hybrid", "hybrid_rerank")
+            alpha: 임베딩 가중치 (0~1)
+        
+        Returns:
+            dict: answer, sources, search_mode, usage
+        """
+        try:
+            start_time = time.time()
+            
+            # 파라미터 설정
+            if top_k is not None:
+                self.top_k = top_k
+            if search_mode is not None:
+                self.search_mode = search_mode
+            if alpha is not None:
+                self.alpha = alpha
+            
+            # Chain 실행
+            answer = self.chain.invoke(query)
+            
+            elapsed_time = time.time() - start_time
+            
+            # 대화 히스토리에 추가
+            self.chat_history.append({"role": "user", "content": query})
+            self.chat_history.append({"role": "assistant", "content": answer})
+            
+            # 토큰 사용량 추정 (LangChain에서는 직접 접근 어려움)
+            estimated_tokens = len(query.split()) + len(answer.split()) * 2
+            
+            return {
+                'answer': answer,
+                'sources': self._format_sources(self._last_retrieved_docs),
+                'search_mode': self.search_mode,
+                'elapsed_time': elapsed_time,
+                'usage': {
+                    'total_tokens': estimated_tokens,
+                    'prompt_tokens': 0,
+                    'completion_tokens': 0
+                }
+            }
+        
+        except Exception as e:
+            print(f"❌ 답변 생성 실패: {e}")
+            import traceback
+            traceback.print_exc()
+            raise RuntimeError(f"답변 생성 실패: {str(e)}") from e
+
+    def chat(self, query: str) -> str:
+        """
+        간단한 대화 인터페이스
+        
+        Args:
+            query: 질문
+        
+        Returns:
+            str: 답변 텍스트만 반환
+        """
+        result = self.generate_answer(query)
+        return result['answer']
+
+    def clear_history(self):
+        """대화 히스토리 초기화"""
+        self.chat_history = []
+        print("🗑️ 대화 히스토리가 초기화되었습니다.")
+
+    def get_history(self) -> List[Dict]:
+        """대화 히스토리 반환"""
+        return self.chat_history.copy()
+
+    def set_search_config(self, search_mode: str = None, top_k: int = None, alpha: float = None):
+        """검색 설정 변경"""
+        if search_mode is not None:
+            self.search_mode = search_mode
+        if top_k is not None:
+            self.top_k = top_k
+        if alpha is not None:
+            self.alpha = alpha
+        
+        print(f"🔧 검색 설정 변경: mode={self.search_mode}, top_k={self.top_k}, alpha={self.alpha}")
+
+    def print_result(self, result: dict, query: str = None):
+        """결과 출력"""
+        print("\n" + "="*60)
+        if query:
+            print(f"질문: {query}")
+        print(f"검색 모드: {result.get('search_mode', 'N/A')}")
+        if 'elapsed_time' in result:
+            print(f"소요 시간: {result['elapsed_time']:.2f}초")
+        print("="*60)
+        print(f"\n💬 답변:\n{result['answer']}")
+        print(f"\n📚 참고 문서 ({len(result['sources'])}개):")
+        for i, source in enumerate(result['sources'], 1):
+            score = source.get('score', 0)
+            score_type = source.get('score_type', '')
+            print(f"  [{i}] {source['filename']}")
+            print(f"      점수: {score:.3f} ({score_type})")
+        print("="*60)
+
+
+# 대화형 실행
+def interactive_mode():
+    """대화형 모드 실행"""
+    print("=" * 60)
+    print("대화형 RAG 시스템 초기화 중...")
+    print("=" * 60)
+    
+    config = RAGConfig()
+    pipeline = RAGPipeline(config=config)
+    
+    print("\n" + "=" * 60)
+    print("대화형 모드 시작")
+    print("명령어: 'quit' (종료), 'clear' (히스토리 초기화), 'mode' (검색모드 변경)")
+    print("=" * 60)
+    
+    while True:
+        user_query = input("\n질문: ").strip()
+        
+        if not user_query:
+            continue
+        
+        if user_query.lower() in ['quit', 'exit', '종료', 'q']:
+            print("시스템을 종료합니다.")
+            break
+        
+        if user_query.lower() == 'clear':
+            pipeline.clear_history()
+            continue
+        
+        if user_query.lower() == 'mode':
+            print("\n검색 모드 선택:")
+            print("1. embedding - 임베딩 검색")
+            print("2. hybrid - BM25 + 임베딩")
+            print("3. hybrid_rerank - Hybrid + Re-ranker (권장)")
+            choice = input("선택 (1/2/3): ").strip()
+            modes = {'1': 'embedding', '2': 'hybrid', '3': 'hybrid_rerank'}
+            if choice in modes:
+                pipeline.set_search_config(search_mode=modes[choice])
+            continue
+        
+        try:
+            result = pipeline.generate_answer(query=user_query)
+            pipeline.print_result(result, user_query)
+            
+            # 소스 출력 여부
+            show_source = input("\n참조 문서 상세 보기? (y/n): ").strip().lower()
+            if show_source == 'y':
+                for i, source in enumerate(result['sources'], 1):
+                    print(f"\n{'='*40}")
+                    print(f"[문서 {i}] {source['filename']}")
+                    print(f"발주기관: {source['organization']}")
+                    print(f"내용:\n{source['content'][:500]}...")
+        
+        except Exception as e:
+            print(f"❌ 오류 발생: {e}")
+
+
+# 사용 예시
+if __name__ == "__main__":
+    interactive_mode()

src/generator/generator_gguf.py

@@ -0,0 +1,580 @@
+from llama_cpp import Llama
+from typing import Optional, Dict, Any, List
+import logging
+import time
+import os
+
+from src.utils.config import RAGConfig
+from src.router.query_router import QueryRouter
+from src.prompts.dynamic_prompts import PromptManager
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class GGUFGenerator:
+    """
+    GGUF 기반 Llama-3 생성기
+    
+    llama.cpp를 사용하여 GGUF 포맷 모델을 로드하고
+    입찰 관련 질의응답을 수행합니다.
+    """
+    
+    def __init__(
+        self,
+        model_path: str,
+        n_gpu_layers: int = 0,
+        n_ctx: int = 2048,
+        n_threads: int = 8,
+        config = None,
+        max_new_tokens: int = 256,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        system_prompt: str = "당신은 RFP(제안요청서) 분석 및 요약 전문가입니다."
+    ):
+        """
+        생성기 초기화
+        
+        Args:
+            model_path: GGUF 모델 파일 경로
+            n_gpu_layers: GPU에 올릴 레이어 수 (0 = CPU만, 35 = 전체 GPU)
+            n_ctx: 최대 컨텍스트 길이
+            n_threads: CPU 스레드 수
+            max_new_tokens: 최대 생성 토큰 수
+            temperature: 생성 다양성 (0.0~1.0)
+            top_p: Nucleus sampling 파라미터
+            system_prompt: 시스템 프롬프트
+        """
+        self.config = config or RAGConfig() 
+        self.model_path = model_path
+        self.n_gpu_layers = n_gpu_layers
+        self.n_ctx = n_ctx
+        self.n_threads = n_threads
+        self.max_new_tokens = max_new_tokens
+        self.temperature = temperature
+        self.top_p = top_p
+        self.system_prompt = system_prompt
+        
+        # 모델 (나중에 로드)
+        self.model = None
+        
+        logger.info(f"GGUFGenerator 초기화 완료")
+    
+    def load_model(self) -> None:
+        """
+        GGUF 모델 로드
+        
+        로직:
+        1. USE_MODEL_HUB 확인
+        2-A. True → Hugging Face Hub에서 다운로드
+        2-B. False → 로컬 파일 사용
+        3. 모델 로드
+        """
+        
+        # 중복 로드 방지
+        if self.model is not None:
+            logger.info("모델이 이미 로드되어 있습니다.")
+            return
+        
+        try:
+            # Model Hub 사용 여부에 따라 경로 결정
+            if self.config.USE_MODEL_HUB:
+                # === Model Hub에서 다운로드 ===
+                logger.info(f"📥 Model Hub에서 다운로드: {self.config.MODEL_HUB_REPO}")
+                
+                from huggingface_hub import hf_hub_download
+                
+                model_path = hf_hub_download(
+                    repo_id=self.config.MODEL_HUB_REPO,
+                    filename=self.config.MODEL_HUB_FILENAME,
+                    cache_dir=self.config.MODEL_CACHE_DIR,
+                    local_dir=self.config.MODEL_CACHE_DIR,
+                    local_dir_use_symlinks=False  # 심볼릭 링크 대신 실제 복사
+                )
+                
+                logger.info(f"✅ 다운로드 완료: {model_path}")
+                
+            else:
+                # === 로컬 파일 사용 ===
+                model_path = self.config.GGUF_MODEL_PATH
+                
+                if not os.path.exists(model_path):
+                    raise FileNotFoundError(
+                        f"❌ 로컬 모델 파일을 찾을 수 없습니다: {model_path}\n"
+                        f"   USE_MODEL_HUB=true로 설정하거나 모델 파일을 준비하세요."
+                    )
+                
+                logger.info(f"📂 로컬 모델 사용: {model_path}")
+            
+            # === 공통: 모델 로드 ===
+            logger.info(f"🚀 GGUF 모델 로드 중...")
+            logger.info(f"   GPU 레이어: {self.n_gpu_layers}")
+            logger.info(f"   컨텍스트: {self.n_ctx}")
+            
+            self.model = Llama(
+                model_path=model_path,
+                n_gpu_layers=self.n_gpu_layers,
+                n_ctx=self.n_ctx,
+                n_threads=self.n_threads,
+                verbose=False,
+            )
+            
+            logger.info("✅ GGUF 모델 로드 완료!")
+            
+        except FileNotFoundError as e:
+            logger.error(f"❌ 모델 파일을 찾을 수 없습니다: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"❌ 모델 로드 실패: {e}")
+            raise RuntimeError(f"모델 로드 중 오류 발생: {e}")
+    
+    def format_prompt(
+        self,
+        question: str,
+        context: Optional[str] = None,
+        system_prompt: Optional[str] = None
+    ) -> str:
+        """
+        Llama-3 Chat 템플릿으로 프롬프트 포맷팅
+        
+        Args:
+            question: 사용자 질문
+            context: 선택적 컨텍스트 (RAG 검��� 결과)
+            system_prompt: 선택적 시스템 프롬프트
+        
+        Returns:
+            포맷된 프롬프트 문자열
+        """
+        # 시스템 프롬프트 설정
+        if system_prompt is None:
+            system_prompt = self.system_prompt
+            logger.warning("⚠️ system_prompt가 None! 기본 프롬프트 사용")
+        else:
+            # 동적 프롬프트 미리보기 (처음 150자만)
+            logger.info(f"✅ 동적 프롬프트 적용:\n{system_prompt[:150]}...")  # ← 추가
+            
+        # 컨텍스트 포함 여부
+        if context is not None:
+            user_message = f"참고 문서:\n{context}\n\n질문: {question}"
+        else:
+            user_message = question
+        
+        # Llama-3 Chat 템플릿 적용
+        formatted_prompt = (
+            f"<|start_header_id|>system<|end_header_id|>\n\n"
+            f"{system_prompt}<|eot_id|>"
+            f"<|start_header_id|>user<|end_header_id|>\n\n"
+            f"{user_message}<|eot_id|>"
+            f"<|start_header_id|>assistant<|end_header_id|>\n\n"
+        )
+        
+        return formatted_prompt
+    
+    def generate(
+        self,
+        prompt: str,
+        max_new_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+    ) -> str:
+        """
+        프롬프트를 입력받아 응답 생성
+        
+        Args:
+            prompt: 포맷된 프롬프트
+            max_new_tokens: 최대 생성 토큰 수
+            temperature: 생성 다양성
+            top_p: Nucleus sampling
+        
+        Returns:
+            생성된 응답 텍스트
+        
+        Raises:
+            RuntimeError: 모델이 로드되지 않은 경우
+        """
+        # 모델 로드 확인
+        if self.model is None:
+            raise RuntimeError(
+                "모델이 로드되지 않았습니다. load_model()을 먼저 호출하세요."
+            )
+        
+        # 파라미터 설정
+        if max_new_tokens is None:
+            max_new_tokens = self.max_new_tokens
+        if temperature is None:
+            temperature = self.temperature
+        if top_p is None:
+            top_p = self.top_p
+        
+        try:
+            logger.info(f"🔄 생성 시작 (max_tokens={max_new_tokens}, temp={temperature})")
+            start_time = time.time()
+            
+            # 생성
+            output = self.model(
+                prompt,
+                max_tokens=max_new_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                echo=False,  # 프롬프트 반복 안 함
+                stop=["<|eot_id|>", "<|end_of_text|>"],  # 종료 토큰
+            )
+            
+            elapsed = time.time() - start_time
+            logger.info(f"✅ 생성 완료: {elapsed:.2f}초")
+            
+            # 응답 추출
+            response = output['choices'][0]['text'].strip()
+            
+            logger.info(f"📝 응답 길이: {len(response)} 글자")
+            return response
+            
+        except Exception as e:
+            logger.error(f"❌ 생성 중 오류 발생: {e}")
+            raise RuntimeError(f"텍스트 생성 실패: {e}")
+    
+    def chat(
+        self,
+        question: str,
+        context: Optional[str] = None,
+        system_prompt=None,
+        **kwargs
+    ) -> str:
+        """
+        질문에 대한 응답 생성 (통합 메서드)
+        
+        Args:
+            question: 사용자 질문
+            context: 선택적 컨텍스트 (RAG 결과)
+            **kwargs: generate() 파라미터
+        
+        Returns:
+            생성된 응답
+        """
+        # 프롬프트 포맷팅 (system_prompt 전달)
+        formatted_prompt = self.format_prompt(
+            question=question,
+            context=context,
+            system_prompt=system_prompt  # ← 추가!
+        )
+        
+        # 응답 생성
+        response = self.generate(formatted_prompt, **kwargs)
+
+        return response
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """
+        모델 정보 반환
+        
+        Returns:
+            모델 정보 딕셔너리
+        """
+        info = {
+            "model_path": self.model_path,
+            "n_gpu_layers": self.n_gpu_layers,
+            "n_ctx": self.n_ctx,
+            "n_threads": self.n_threads,
+            "is_loaded": self.model is not None,
+            "max_new_tokens": self.max_new_tokens,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+        }
+        
+        return info
+    
+    def __repr__(self):
+        return f"GGUFGenerator(model={self.model_path}, loaded={self.model is not None})"
+
+
+# ===== GGUF RAGPipeline: chatbot_app.py 호환용 =====
+
+class GGUFRAGPipeline:
+    """
+    GGUF 모델 기반 RAG 파이프라인
+    
+    RAGPipeline(API 버전)과 동일한 인터페이스를 제공하여
+    chatbot_app.py와 호환됩니다.
+    """
+    
+    def __init__(self, config=None, model: str = None, top_k: int = None):
+        """
+        초기화
+        
+        Args:
+            config: RAGConfig 객체
+            model: 모델 이름 (사용 안 함, 호환성용)
+            top_k: 기본 검색 문서 수
+        """
+        # Config import (지연 import로 순환 참조 방지)
+        from src.utils.config import RAGConfig
+        from src.retriever.retriever import RAGRetriever
+        
+        self.config = config or RAGConfig()
+        self.top_k = top_k or self.config.DEFAULT_TOP_K
+        
+        # 검색 설정
+        self.search_mode = self.config.DEFAULT_SEARCH_MODE
+        self.alpha = self.config.DEFAULT_ALPHA
+        
+        # Retriever 초기화
+        logger.info("RAGRetriever 초기화 중...")
+        self.retriever = RAGRetriever(config=self.config)
+        
+        # GGUFGenerator 초기화
+        logger.info("GGUFGenerator 초기화 중...")
+        self.generator = GGUFGenerator(
+            model_path=self.config.GGUF_MODEL_PATH,
+            n_gpu_layers=self.config.GGUF_N_GPU_LAYERS,
+            n_ctx=self.config.GGUF_N_CTX,
+            n_threads=self.config.GGUF_N_THREADS,
+            max_new_tokens=self.config.GGUF_MAX_NEW_TOKENS,
+            temperature=self.config.GGUF_TEMPERATURE,
+            top_p=self.config.GGUF_TOP_P,
+            system_prompt=self.config.SYSTEM_PROMPT
+        )
+        
+        # 모델 로드 (시간 소요)
+        logger.info("GGUF 모델 로드 중...")
+        self.generator.load_model()
+        
+        # 대화 히스토리
+        self.chat_history: List[Dict] = []
+        
+        # 마지막 검색 결과 저장 (sources 반환용)
+        self._last_retrieved_docs = []
+        
+        logger.info("✅ GGUFRAGPipeline 초기화 완료")
+        logger.info(f"   - 검색 모드: {self.search_mode}")
+        logger.info(f"   - 기본 top_k: {self.top_k}")
+    
+    def _retrieve_and_format(self, query: str) -> str:
+        """검색 수행 및 컨텍스트 포맷팅"""
+        # 검색 모드에 따라 문서 검색
+        if self.search_mode == "embedding":
+            docs = self.retriever.search(query, top_k=self.top_k)
+        elif self.search_mode == "embedding_rerank":
+            docs = self.retriever.search_with_rerank(query, top_k=self.top_k)
+        elif self.search_mode == "hybrid":
+            docs = self.retriever.hybrid_search(
+                query, top_k=self.top_k, alpha=self.alpha
+            )
+        elif self.search_mode == "hybrid_rerank":
+            docs = self.retriever.hybrid_search_with_rerank(
+                query, top_k=self.top_k, alpha=self.alpha
+            )
+        else:
+            docs = self.retriever.search(query, top_k=self.top_k)
+        
+        # 마지막 검색 결과 저장
+        self._last_retrieved_docs = docs
+        
+        # 컨텍스트 포맷팅
+        return self._format_context(docs)
+    
+    def _format_context(self, retrieved_docs: list) -> str:
+        """검색된 문서를 컨텍스트로 변환"""
+        if not retrieved_docs:
+            return "관련 문서를 찾을 수 없습니다."
+        
+        context_parts = []
+        for i, doc in enumerate(retrieved_docs, 1):
+            context_parts.append(f"[문서 {i}]\n{doc['content']}\n")
+        
+        return "\n".join(context_parts)
+    
+    def _format_sources(self, retrieved_docs: list) -> list:
+        """검색된 문서를 sources 형식으로 변환"""
+        sources = []
+        for doc in retrieved_docs:
+            source_info = {
+                'content': doc['content'],
+                'metadata': doc['metadata'],
+                'filename': doc.get('filename', 'N/A'),
+                'organization': doc.get('organization', 'N/A')
+            }
+            
+            # 검색 모드에 따라 점수 필드가 다름
+            if 'rerank_score' in doc:
+                source_info['score'] = doc['rerank_score']
+                source_info['score_type'] = 'rerank'
+            elif 'hybrid_score' in doc:
+                source_info['score'] = doc['hybrid_score']
+                source_info['score_type'] = 'hybrid'
+            elif 'relevance_score' in doc:
+                source_info['score'] = doc['relevance_score']
+                source_info['score_type'] = 'embedding'
+            else:
+                source_info['score'] = 0
+                source_info['score_type'] = 'unknown'
+            
+            sources.append(source_info)
+        
+        return sources
+    
+    def _estimate_usage(self, query: str, answer: str) -> dict:
+        """토큰 사용량 추정"""
+        # 간단한 단어 수 기반 추정
+        prompt_tokens = len(query.split()) * 2
+        completion_tokens = len(answer.split()) * 2
+        
+        return {
+            'total_tokens': prompt_tokens + completion_tokens,
+            'prompt_tokens': prompt_tokens,
+            'completion_tokens': completion_tokens
+        }
+    
+    def generate_answer(
+        self,
+        query: str,
+        top_k: int = None,
+        search_mode: str = None,
+        alpha: float = None
+    ) -> dict:
+        """
+        답변 생성 (chatbot_app.py 호환 메인 메서드)
+        
+        Args:
+            query: 질문
+            top_k: 검색할 문서 수
+            search_mode: 검색 모드
+            alpha: 임베딩 가중치
+        
+        Returns:
+            dict: answer, sources, search_mode, usage, elapsed_time, used_retrieval
+        """
+        try:
+            start_time = time.time()
+            
+            # 파라미터 설정 (검색 전에 먼저 설정)
+            if top_k is not None:
+                self.top_k = top_k
+            if search_mode is not None:
+                self.search_mode = search_mode
+            if alpha is not None:
+                self.alpha = alpha
+
+            # ===== Router로 검색 여부 결정 =====
+            router = QueryRouter()
+            classification = router.classify(query)
+            query_type = classification['type']  # 'greeting'/'thanks'/'document'/'out_of_scope'
+            
+            logger.info(f"📍 분류: {query_type} "
+                f"(신뢰도: {classification['confidence']:.2f})")
+            
+            # 2. 타입별 처리
+            if query_type in ['greeting', 'thanks', 'out_of_scope']:
+                # 검색 스킵
+                context = None
+                used_retrieval = False
+                self._last_retrieved_docs = []
+                
+                # 동적 프롬프트 선택
+                system_prompt = PromptManager.get_prompt(query_type)
+                logger.info(f"⏭️ RAG 스킵: {query_type}")
+            
+            elif query_type == 'document':
+                # RAG 수행
+                context = self._retrieve_and_format(query)
+                used_retrieval = True
+                
+                # 동적 프롬프트 (context 포함)
+                system_prompt = PromptManager.get_prompt('document')
+                logger.info(f"🔍 RAG 수행: {len(self._last_retrieved_docs)}개 문서")
+            
+            # 3. 답변 생성 (system_prompt 전달)
+            answer = self.generator.chat(
+                question=query,
+                context=context,
+                system_prompt=system_prompt  # ← 추가!
+            )
+            
+            elapsed_time = time.time() - start_time
+            
+            # 대화 히스토리에 추가
+            self.chat_history.append({"role": "user", "content": query})
+            self.chat_history.append({"role": "assistant", "content": answer})
+            
+            # 결과 반환 (RAGPipeline과 동일 형식)
+            return {
+                'answer': answer,
+                'sources': self._format_sources(self._last_retrieved_docs),
+                'used_retrieval': used_retrieval,
+                'query_type': query_type,  # ← 추가!
+                'search_mode': self.search_mode if used_retrieval else 'direct',
+                'routing_info': classification,
+                'elapsed_time': elapsed_time,
+                'usage': self._estimate_usage(query, answer)
+            }
+        
+        except Exception as e:
+            logger.error(f"❌ 답변 생성 실패: {e}")
+            import traceback
+            traceback.print_exc()
+            raise RuntimeError(f"답변 생성 실패: {str(e)}") from e
+    
+    def chat(self, query: str) -> str:
+        """간단한 대화 인터페이스"""
+        result = self.generate_answer(query)
+        return result['answer']
+    
+    def clear_history(self):
+        """대화 히스토리 초기화"""
+        self.chat_history = []
+        logger.info("🗑️ 대화 히스토리가 초기화되었습니다.")
+    
+    def get_history(self) -> List[Dict]:
+        """대화 히스토리 반환"""
+        return self.chat_history.copy()
+    
+    def set_search_config(
+        self,
+        search_mode: str = None,
+        top_k: int = None,
+        alpha: float = None
+    ):
+        """검색 설정 변경"""
+        if search_mode is not None:
+            self.search_mode = search_mode
+        if top_k is not None:
+            self.top_k = top_k
+        if alpha is not None:
+            self.alpha = alpha
+        
+        logger.info(
+            f"🔧 검색 설정 변경: mode={self.search_mode}, "
+            f"top_k={self.top_k}, alpha={self.alpha}"
+        )
+
+
+# 테스트용
+if __name__ == "__main__":
+    from src.utils.config import RAGConfig
+    
+    config = RAGConfig()
+    
+    # GGUFRAGPipeline 초기화
+    pipeline = GGUFRAGPipeline(config=config)
+    
+    # 테스트 질문들
+    test_questions = [
+        "안녕하세요",
+        "본 사업의 예산 범위는 어떻게 되나요?",
+        "고마워요!"
+    ]
+    
+    for question in test_questions:
+        print("\n" + "="*50)
+        print("테스트 질문:", question)
+        print("="*50)
+        
+        result = pipeline.generate_answer(question)
+        
+        print(f"\n라우팅: {result['routing_info']['route']}")
+        print(f"검색 사용: {result['used_retrieval']}")
+        print("\n응답:")
+        print(result['answer'])
+        print(f"\n소요 시간: {result['elapsed_time']:.2f}초")
+        print(f"참고 문서: {len(result['sources'])}개")
+        print("="*50)

src/generator/generator_lee.py

@@ -0,0 +1,377 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough, RunnableLambda
+from langchain_core.messages import HumanMessage, AIMessage
+from langsmith import traceable
+import time
+from typing import List, Dict
+
+from src.utils.config import RAGConfig
+from src.retriever.retriever import RAGRetriever
+from src.router.query_router import QueryRouter
+
+
+class RAGPipeline:
+    """대화형 RAG 파이프라인 - LangChain Chain 기반"""
+
+    def __init__(self, config: RAGConfig = None, model: str = None, top_k: int = None):
+        """초기화"""
+        self.config = config or RAGConfig()
+        self.model = model or self.config.LLM_MODEL_NAME
+        self.top_k = top_k or self.config.DEFAULT_TOP_K
+        
+        # 검색 설정
+        self.search_mode = self.config.DEFAULT_SEARCH_MODE
+        self.alpha = self.config.DEFAULT_ALPHA
+
+        # LLM 초기화 (LangChain ChatOpenAI)
+        self.llm = ChatOpenAI(
+            model=self.model,
+            openai_api_key=self.config.OPENAI_API_KEY,
+            timeout=60.0,
+            max_retries=3
+        )
+
+        # Retriever 및 라우터 초기화
+        self.retriever = RAGRetriever(config=self.config)
+        self.router = QueryRouter()
+        self._direct_responses = {
+            'greeting': "안녕하세요! 공공입찰 RFP 관련 궁금한 사항을 알려주시면 자료를 찾아 드릴게요.",
+            'thanks': "도움이 되었다니 다행입니다. 추가로 궁금한 점이 있으면 언제든지 말씀해 주세요!",
+            'out_of_scope': "해당 질문은 현재 보유한 입찰·사업 문서에서 다루지 않습니다. 다른 질문을 시도해 주세요."
+        }
+        
+        # 대화 히스토리
+        self.chat_history: List[Dict] = []
+        
+        # 마지막 검색 결과 저장 (sources 반환용)
+        self._last_retrieved_docs = []
+
+        # 프롬프트 템플릿 (대화 히스토리 포함)
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", """당신은 공공입찰 RFP를 분석하는 입찰메이트 사내 분석가입니다. 제공된 컨텍스트만으로 요구사항·예산·대상 기관·제출 방식 등을 구조화해 의사결정을 지원하세요.
+
+            # 규칙
+            - 답변은 한국어로 작성합니다.
+            - 컨텍스트 밖 내용을 추측하지 않습니다.
+            - 컨텍스트가 비어있거나 질문과 직접 관련된 사실이 없으면 "문서에서 해당 정보를 찾을 수 없습니다." 한 문장으로만 답합니다.
+            - 여러 문서를 비교할 때는 문서별 차이를 표 또는 목록으로 정리합니다.
+            - 숫자에는 가능한 단위를 포함합니다.
+            - 직전 대화 맥락을 반영하되, 확인되지 않은 내용을 추론해 추가하지 않습니다.
+
+            # 답변 형식
+            1. 한 줄 요약: 질문 핵심을 한두 문장으로 작성합니다.
+            2. 상세 답변: [요구사항], [대상 기관], [예산], [제출 형식/방법], [평가 기준] 등 문서에서 확인된 항목만 정리합니다.
+            3. 근거 정보: 위 답변의 근거가 된 문장이나 문단을 요약합니다.
+            4. 부족한 정보: 문서에서 찾을 수 없는 항목은 "문서에서 확인 불가"로 표기합니다."""),
+                        
+                        # 대화 히스토리
+                        MessagesPlaceholder(variable_name="chat_history"),
+                        
+                        # 현재 질문과 컨텍스트
+                        ("user", """# 컨텍스트
+            {context}
+
+            # 질문
+            {question}
+
+            위 규칙에 따라 답변하세요.""")
+        ])
+
+        # Chain 구성
+        self.chain = (
+            {
+                "context": RunnableLambda(self._retrieve_and_format),
+                "question": RunnablePassthrough(),
+                "chat_history": RunnableLambda(lambda x: self._get_chat_history())
+            }
+            | self.prompt
+            | self.llm
+            | StrOutputParser()
+        )
+
+        print(f"✅ RAG 파이프라인 초기화 완료")
+        print(f"   - 모델: {self.model}")
+        print(f"   - 기본 top_k: {self.top_k}")
+        print(f"   - 검색 모드: {self.search_mode}")
+
+    def _get_chat_history(self) -> List:
+        """대화 히스토리를 LangChain 메시지 형식으로 변환"""
+        messages = []
+        for msg in self.chat_history:
+            if msg["role"] == "user":
+                messages.append(HumanMessage(content=msg["content"]))
+            else:
+                messages.append(AIMessage(content=msg["content"]))
+        return messages
+
+    def _retrieve_and_format(self, query: str) -> str:
+        """검��� 수행 및 컨텍스트 포맷팅"""
+        # 검색 모드에 따라 문서 검색
+        if self.search_mode == "embedding":
+            docs = self.retriever.search(query, top_k=self.top_k)
+        elif self.search_mode == "hybrid":
+            docs = self.retriever.hybrid_search(query, top_k=self.top_k, alpha=self.alpha)
+        elif self.search_mode == "hybrid_rerank":
+            docs = self.retriever.hybrid_search_with_rerank(
+                query, top_k=self.top_k, alpha=self.alpha
+            )
+        else:
+            docs = self.retriever.search(query, top_k=self.top_k)
+        
+        # 마지막 검색 결과 저장
+        self._last_retrieved_docs = docs
+        
+        # 컨텍스트 포맷팅
+        return self._format_context(docs)
+
+    def _format_context(self, retrieved_docs: list) -> str:
+        """검색된 문서를 컨텍스트로 변환"""
+        if not retrieved_docs:
+            return "관련 문서를 찾을 수 없습니다."
+        
+        context_parts = []
+        for i, doc in enumerate(retrieved_docs, 1):
+            context_parts.append(f"[문서 {i}]\n{doc['content']}\n")
+        return "\n".join(context_parts)
+
+    def _format_sources(self, retrieved_docs: list) -> list:
+        """검색된 문서를 sources 형식으로 변환"""
+        sources = []
+        for doc in retrieved_docs:
+            source_info = {
+                'content': doc['content'],
+                'metadata': doc['metadata'],
+                'filename': doc.get('filename', 'N/A'),
+                'organization': doc.get('organization', 'N/A')
+            }
+            
+            # 검색 모드에 따라 점수 필드가 다름
+            if 'rerank_score' in doc:
+                source_info['score'] = doc['rerank_score']
+                source_info['score_type'] = 'rerank'
+            elif 'hybrid_score' in doc:
+                source_info['score'] = doc['hybrid_score']
+                source_info['score_type'] = 'hybrid'
+            elif 'relevance_score' in doc:
+                source_info['score'] = doc['relevance_score']
+                source_info['score_type'] = 'embedding'
+            else:
+                source_info['score'] = 0
+                source_info['score_type'] = 'unknown'
+            
+            sources.append(source_info)
+        return sources
+
+    @traceable(
+        name="RAG_Generate_Answer",
+        metadata={"component": "generator", "version": "2.0"}
+    )
+    def generate_answer(
+        self, 
+        query: str, 
+        top_k: int = None,
+        search_mode: str = None,
+        alpha: float = None
+    ) -> dict:
+        """
+        답변 생성 (Chain 기반)
+        
+        Args:
+            query: 질문
+            top_k: 검색할 문서 수
+            search_mode: 검색 모드 ("embedding", "hybrid", "hybrid_rerank")
+            alpha: 임베딩 가중치 (0~1)
+        
+        Returns:
+            dict: answer, sources, search_mode, usage
+        """
+        try:
+            start_time = time.time()
+
+            classification = self.router.classify(query)
+            query_type = classification.get('type', 'document')
+
+            # 비문서 질의는 즉시 응답
+            if query_type != 'document':
+                print(f"⏭️  라우터: 검색 생략 ({query_type})")
+                answer = self._direct_responses.get(
+                    query_type,
+                    self._direct_responses['out_of_scope']
+                )
+                elapsed_time = time.time() - start_time
+                self._last_retrieved_docs = []
+
+                self.chat_history.append({"role": "user", "content": query})
+                self.chat_history.append({"role": "assistant", "content": answer})
+
+                return {
+                    'answer': answer,
+                    'sources': [],
+                    'search_mode': 'none',
+                    'elapsed_time': elapsed_time,
+                    'usage': {
+                        'total_tokens': 0,
+                        'prompt_tokens': 0,
+                        'completion_tokens': 0
+                    },
+                    'routing': classification
+                }
+
+            # 파라미터 설정
+            if top_k is not None:
+                self.top_k = top_k
+            if search_mode is not None:
+                self.search_mode = search_mode
+            if alpha is not None:
+                self.alpha = alpha
+            
+            # Chain 실행
+            answer = self.chain.invoke(query)
+            
+            # 검색 결과가 없으면 안전 응답으로 대체
+            if not self._last_retrieved_docs:
+                answer = "문서에서 관련 정보를 찾을 수 없습니다. 다른 질문을 입력해 주세요."
+                print("⚠️  검색 결과 없음 - 안전 응답 반환")
+            
+            elapsed_time = time.time() - start_time
+            
+            # 대화 히스토리에 추가
+            self.chat_history.append({"role": "user", "content": query})
+            self.chat_history.append({"role": "assistant", "content": answer})
+            
+            # 토큰 사용량 추정 (LangChain에서는 직접 접근 어려움)
+            estimated_tokens = len(query.split()) + len(answer.split()) * 2
+            
+            return {
+                'answer': answer,
+                'sources': self._format_sources(self._last_retrieved_docs),
+                'search_mode': self.search_mode,
+                'elapsed_time': elapsed_time,
+                'usage': {
+                    'total_tokens': estimated_tokens,
+                    'prompt_tokens': 0,
+                    'completion_tokens': 0
+                },
+                'routing': classification
+            }
+        
+        except Exception as e:
+            print(f"❌ 답변 생성 실패: {e}")
+            import traceback
+            traceback.print_exc()
+            raise RuntimeError(f"답변 생성 실패: {str(e)}") from e
+
+    def chat(self, query: str) -> str:
+        """
+        간단한 대화 인터페이스
+        
+        Args:
+            query: 질문
+        
+        Returns:
+            str: 답변 텍스트만 반환
+        """
+        result = self.generate_answer(query)
+        return result['answer']
+
+    def clear_history(self):
+        """대화 히스토리 초기화"""
+        self.chat_history = []
+        print("🗑️ 대화 히스토리가 초기화되었습니다.")
+
+    def get_history(self) -> List[Dict]:
+        """대화 히스토리 반환"""
+        return self.chat_history.copy()
+
+    def set_search_config(self, search_mode: str = None, top_k: int = None, alpha: float = None):
+        """검색 설정 변경"""
+        if search_mode is not None:
+            self.search_mode = search_mode
+        if top_k is not None:
+            self.top_k = top_k
+        if alpha is not None:
+            self.alpha = alpha
+        
+        print(f"🔧 검색 설정 변경: mode={self.search_mode}, top_k={self.top_k}, alpha={self.alpha}")
+
+    def print_result(self, result: dict, query: str = None):
+        """결과 출력"""
+        print("\n" + "="*60)
+        if query:
+            print(f"질문: {query}")
+        print(f"검색 모드: {result.get('search_mode', 'N/A')}")
+        if 'elapsed_time' in result:
+            print(f"소요 시간: {result['elapsed_time']:.2f}초")
+        print("="*60)
+        print(f"\n💬 답변:\n{result['answer']}")
+        print(f"\n📚 참고 문서 ({len(result['sources'])}개):")
+        for i, source in enumerate(result['sources'], 1):
+            score = source.get('score', 0)
+            score_type = source.get('score_type', '')
+            print(f"  [{i}] {source['filename']}")
+            print(f"      점수: {score:.3f} ({score_type})")
+        print("="*60)
+
+
+# 대화형 실행
+def interactive_mode():
+    """대화형 모드 실행"""
+    print("=" * 60)
+    print("대화형 RAG 시스템 초기화 중...")
+    print("=" * 60)
+    
+    config = RAGConfig()
+    pipeline = RAGPipeline(config=config)
+    
+    print("\n" + "=" * 60)
+    print("대화형 모드 시작")
+    print("명령어: 'quit' (종료), 'clear' (히스토리 초기화), 'mode' (검색모드 변경)")
+    print("=" * 60)
+    
+    while True:
+        user_query = input("\n질문: ").strip()
+        
+        if not user_query:
+            continue
+        
+        if user_query.lower() in ['quit', 'exit', '종료', 'q']:
+            print("시스템을 종료합니다.")
+            break
+        
+        if user_query.lower() == 'clear':
+            pipeline.clear_history()
+            continue
+        
+        if user_query.lower() == 'mode':
+            print("\n검색 모드 선택:")
+            print("1. embedding - 임베딩 검색")
+            print("2. hybrid - BM25 + 임베딩")
+            print("3. hybrid_rerank - Hybrid + Re-ranker (권장)")
+            choice = input("선택 (1/2/3): ").strip()
+            modes = {'1': 'embedding', '2': 'hybrid', '3': 'hybrid_rerank'}
+            if choice in modes:
+                pipeline.set_search_config(search_mode=modes[choice])
+            continue
+        
+        try:
+            result = pipeline.generate_answer(query=user_query)
+            pipeline.print_result(result, user_query)
+            
+            # 소스 출력 여부
+            show_source = input("\n참조 문서 상세 보기? (y/n): ").strip().lower()
+            if show_source == 'y':
+                for i, source in enumerate(result['sources'], 1):
+                    print(f"\n{'='*40}")
+                    print(f"[문서 {i}] {source['filename']}")
+                    print(f"발주기관: {source['organization']}")
+                    print(f"내용:\n{source['content'][:500]}...")
+        
+        except Exception as e:
+            print(f"❌ 오류 발생: {e}")
+
+
+# 사용 예시
+if __name__ == "__main__":
+    interactive_mode()

src/loader/preprocess_pipeline.py

@@ -0,0 +1,553 @@
+"""
+RAG 데이터 전처리 전체 파이프라인
+텍스트 추출 → 정제 → 청킹 → 저장
+
+모든 전처리 클래스를 하나의 파일로 통합
+"""
+
+import os
+import re
+import zlib
+import struct
+import pandas as pd
+from tqdm import tqdm
+from pypdf import PdfReader
+import olefile
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+from src.utils.config import PreprocessConfig
+
+
+# ============================================================
+# 텍스트 추출 클래스
+# ============================================================
+
+class TextExtractor:
+    """PDF 및 HWP 파일에서 텍스트 추출"""
+    
+    @staticmethod
+    def extract_pdf(filepath: str) -> str:
+        """
+        PDF 파일에서 텍스트 추출
+        
+        Args:
+            filepath: PDF 파일 경로
+            
+        Returns:
+            추출된 텍스트
+        """
+        try:
+            reader = PdfReader(filepath)
+            page_texts = [
+                page.extract_text() 
+                for page in reader.pages 
+                if page.extract_text()
+            ]
+            return "\n\n".join(page_texts)
+        except Exception as e:
+            return f"[PDF 추출 실패: {e}]"
+    
+    @staticmethod
+    def extract_hwp(filepath: str) -> str:
+        """
+        HWP 파일에서 텍스트 추출
+        
+        Args:
+            filepath: HWP 파일 경로
+            
+        Returns:
+            추출된 텍스트
+        """
+        try:
+            f = olefile.OleFileIO(filepath)
+            dirs = f.listdir()
+            
+            # HWP 5.0 파일 검증
+            if ["FileHeader"] not in dirs or ["\x05HwpSummaryInformation"] not in dirs:
+                return "[HWP 추출 실패: 유효한 HWP 5.0 파일이 아님]"
+            
+            # 압축 여부 확인
+            header = f.openstream("FileHeader")
+            header_data = header.read()
+            is_compressed = (header_data[36] & 1) == 1
+            
+            # 섹션 번호 정렬
+            nums = [
+                int(d[1][len("Section"):]) 
+                for d in dirs 
+                if d[0] == "BodyText"
+            ]
+            sections = [f"BodyText/Section{x}" for x in sorted(nums)]
+            
+            # 텍스트 추출
+            text = ""
+            for section in sections:
+                bodytext = f.openstream(section)
+                data = bodytext.read()
+                
+                # 압축 해제
+                if is_compressed:
+                    unpacked_data = zlib.decompress(data, -15)
+                else:
+                    unpacked_data = data
+                
+                # 레코드 파싱
+                i = 0
+                size = len(unpacked_data)
+                while i < size:
+                    header = struct.unpack_from("<I", unpacked_data, i)[0]
+                    rec_type = header & 0x3ff
+                    rec_len = (header >> 20) & 0xfff
+                    
+                    # 텍스트 레코드 (타입 67)
+                    if rec_type == 67:
+                        rec_data = unpacked_data[i + 4 : i + 4 + rec_len]
+                        text += rec_data.decode('utf-16', errors='ignore')
+                    
+                    i += 4 + rec_len
+            
+            f.close()
+            return text
+            
+        except Exception as e:
+            return f"[HWP 추출 실패: {e}]"
+    
+    @staticmethod
+    def extract(filepath: str, file_format: str) -> str:
+        """
+        파일 형식에 따라 텍스트 추출
+        
+        Args:
+            filepath: 파일 경로
+            file_format: 파일 형식 ('pdf' 또는 'hwp')
+            
+        Returns:
+            추출된 텍스트
+        """
+        if not os.path.exists(filepath):
+            return "[추출 실패: 파일 없음]"
+        
+        file_format = file_format.lower()
+        
+        if file_format == 'pdf':
+            return TextExtractor.extract_pdf(filepath)
+        elif file_format == 'hwp':
+            return TextExtractor.extract_hwp(filepath)
+        else:
+            return f"[추출 실패: 알 수 없는 파일 형식 ({file_format})]"
+
+
+# ============================================================
+# 텍스트 정제 클래스
+# ============================================================
+
+class TextCleaner:
+    """텍스트 정제 및 검증"""
+    
+    @staticmethod
+    def clean(text: str) -> str:
+        """
+        텍스트 정제
+        - 특수문자 제거 (한글, 영문, 숫자, 기본 공백문자만 유지)
+        - NULL 문자 제거
+        
+        Args:
+            text: 원본 텍스트
+            
+        Returns:
+            정제된 텍스트
+        """
+        # 허용: 영문, 숫자, 공백, 탭, 줄바꿈, 한글
+        cleaned = re.sub(
+            r'[^\x20-\x7E\n\r\t\uAC00-\uD7AF]', 
+            '', 
+            str(text)
+        )
+        
+        # NULL 문자 제거
+        cleaned = cleaned.replace('\x00', '')
+        
+        return cleaned
+    
+    @staticmethod
+    def validate(text: str, min_length: int = 100) -> bool:
+        """
+        텍스트 유효성 검사
+        
+        Args:
+            text: 검증할 텍스트
+            min_length: 최소 길이
+            
+        Returns:
+            유효 여부
+        """
+        if not text or text.strip() == "":
+            return False
+        
+        if "[추출 실패" in text:
+            return False
+        
+        if len(text) < min_length:
+            return False
+        
+        return True
+    
+    @staticmethod
+    def get_stats(text: str) -> dict:
+        """
+        텍스트 통계 정보
+        
+        Args:
+            text: 분석할 텍스트
+            
+        Returns:
+            통계 딕셔너리
+        """
+        return {
+            'length': len(text),
+            'lines': text.count('\n') + 1,
+            'words': len(text.split()),
+            'is_valid': TextCleaner.validate(text)
+        }
+
+
+# ============================================================
+# 문서 청킹 클래스
+# ============================================================
+
+class DocumentChunker:
+    """문서를 청크로 분할"""
+    
+    def __init__(self, config: PreprocessConfig):
+        """
+        초기화
+        
+        Args:
+            config: 전처리 설정 객체
+        """
+        self.config = config
+        
+        # LangChain 텍스트 분할기 초기화
+        self.splitter = RecursiveCharacterTextSplitter(
+            chunk_size=config.CHUNK_SIZE,
+            chunk_overlap=config.CHUNK_OVERLAP,
+            separators=config.SEPARATORS,
+            length_function=len,
+        )
+    
+    def chunk_document(self, text: str, metadata: dict) -> list:
+        """
+        단일 문서 청킹
+        
+        Args:
+            text: 문서 텍스트
+            metadata: 문서 메타데이터
+            
+        Returns:
+            청크 리스트
+        """
+        try:
+            chunks = self.splitter.split_text(text)
+        except Exception as e:
+            print(f"WARNING: 문서 분할 실패 - {e}")
+            return []
+        
+        chunk_records = []
+        filename = metadata.get('파일명', 'unknown')
+        
+        for i, chunk_content in enumerate(chunks, 1):
+            chunk_record = metadata.copy()
+            chunk_record['chunk_id'] = f"{filename}_chunk_{i:04d}"
+            chunk_record['chunk_content'] = chunk_content
+            chunk_records.append(chunk_record)
+        
+        return chunk_records
+    
+    def chunk_dataframe(
+        self, 
+        df: pd.DataFrame, 
+        text_column: str = 'text_content'
+    ) -> pd.DataFrame:
+        """
+        DataFrame 전체 청킹
+        
+        Args:
+            df: 원본 DataFrame
+            text_column: 텍스트가 들어있는 컬럼명
+            
+        Returns:
+            청크 DataFrame
+        """
+        print(f"청킹 시작 (크기: {self.config.CHUNK_SIZE}, "
+              f"오버랩: {self.config.CHUNK_OVERLAP})...")
+        
+        all_chunks = []
+        
+        for index, row in tqdm(df.iterrows(), total=len(df), desc="청킹"):
+            text = row[text_column]
+            
+            # 메타데이터 준비 (텍스트 컬럼 제외)
+            metadata = row.to_dict()
+            metadata.pop(text_column, None)
+            metadata.pop('text_length', None)
+            
+            # 청킹
+            chunks = self.chunk_document(text, metadata)
+            all_chunks.extend(chunks)
+        
+        df_chunks = pd.DataFrame(all_chunks)
+        
+        print(f"청킹 완료: 원본 {len(df)}개 → 청크 {len(df_chunks)}개")
+        
+        return df_chunks
+
+
+# ============================================================
+# RAG 전처리 파이프라인
+# ============================================================
+
+class RAGPreprocessPipeline:
+    """RAG 데이터 전처리 전체 파이프라인"""
+    
+    def __init__(self, config: PreprocessConfig = None):
+        """
+        초기화
+        
+        Args:
+            config: 전처리 설정 (None이면 기본값)
+        """
+        self.config = config or PreprocessConfig()
+        self.extractor = TextExtractor()
+        self.cleaner = TextCleaner()
+        self.chunker = DocumentChunker(self.config)
+        
+        # 통계 정보
+        self.stats = {
+            'total_files': 0,
+            'success_files': 0,
+            'failed_files': 0,
+            'total_chunks': 0
+        }
+    
+    def extract_from_files(self) -> pd.DataFrame:
+        """
+        1단계: 파일에서 텍스트 추출
+        
+        Returns:
+            텍스트가 추출된 DataFrame
+        """
+        print("\n" + "="*60)
+        print("1단계: 텍스트 추출")
+        print("="*60)
+        
+        # 메타데이터 로드
+        df = pd.read_csv(self.config.META_CSV_PATH)
+        self.stats['total_files'] = len(df)
+        print(f"파일 로드 완료: {len(df)}개")
+        
+        extracted_data = []
+        
+        for index, row in tqdm(df.iterrows(), total=len(df), desc="텍스트 추출"):
+            filepath = os.path.join(self.config.BASE_FOLDER_PATH, row['파일명'])
+            file_format = row['파일형식']
+            
+            # 텍스트 추출
+            raw_text = self.extractor.extract(filepath, file_format)
+            
+            # 정제
+            cleaned_text = self.cleaner.clean(raw_text)
+            
+            # HWP 특수 처리 (텍스트가 너무 짧으면 실패로 간주)
+            if file_format == 'hwp' and len(cleaned_text) < self.config.MIN_TEXT_LENGTH:
+                if "[추출 실패" not in cleaned_text:
+                    cleaned_text = "[추출 실패: HWP 텍스트 너무 짧음]"
+            
+            # 통계 업데이트
+            if self.cleaner.validate(cleaned_text):
+                self.stats['success_files'] += 1
+            else:
+                self.stats['failed_files'] += 1
+            
+            # 결과 저장
+            new_row = row.to_dict()
+            new_row['full_text'] = cleaned_text
+            
+            # 불필요한 컬럼 제거
+            if '텍스트' in new_row:
+                del new_row['텍스트']
+            
+            extracted_data.append(new_row)
+        
+        result_df = pd.DataFrame(extracted_data)
+        
+        print(f"\n텍스트 추출 완료:")
+        print(f"  - 성공: {self.stats['success_files']}개")
+        print(f"  - 실패: {self.stats['failed_files']}개")
+        
+        return result_df
+    
+    def clean_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        2단계: DataFrame 정제
+        
+        Args:
+            df: 원본 DataFrame
+            
+        Returns:
+            정제된 DataFrame
+        """
+        print("\n" + "="*60)
+        print("2단계: 텍스트 정제")
+        print("="*60)
+        
+        # 컬럼명 변경
+        df['text_content'] = df['full_text']
+        df = df.drop(columns=['full_text'])
+        
+        # 결측치 처리
+        df['text_content'] = df['text_content'].fillna('')
+        
+        # 통계 정보 추가
+        df['text_length'] = df['text_content'].apply(len)
+        
+        print(f"텍스트 정제 완료")
+        print(f"  - 평균 길이: {df['text_length'].mean():.0f} 문자")
+        print(f"  - 최소 길이: {df['text_length'].min()} 문자")
+        print(f"  - 최대 길이: {df['text_length'].max()} 문자")
+        
+        return df
+    
+    def create_chunks(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        3단계: 청킹
+        
+        Args:
+            df: 정제된 DataFrame
+            
+        Returns:
+            청크 DataFrame
+        """
+        print("\n" + "="*60)
+        print("3단계: 청킹")
+        print("="*60)
+        
+        # [추가] 필터링 전 상태 확인
+        original_count = len(df)
+        print(f"🔍 필터링 전 문서 수: {original_count}")
+        
+        # 샘플 텍스트 미리보기
+        if len(df) > 0:
+            sample = df['text_content'].iloc[0]
+            print(f"🔍 첫 번째 문서 미리보기:")
+            print(f"   시작 부분: {sample[:100]}...")
+            print(f"   전체 길이: {len(sample)}자")
+            
+            # 추출 실패 패턴이 있는지 확인
+            has_failure = any([
+                '[추출 실패' in sample,
+                '[PDF 추출 실패' in sample,
+                '[HWP 추출 실패' in sample
+            ])
+            print(f"   추출 실패 포함?: {has_failure}")
+        
+        # 추출 실패 문서 필터링 (raw string 사용)
+        df = df[~df['text_content'].str.contains(r'\[추출 실패', na=False)]
+        df = df[~df['text_content'].str.contains(r'\[PDF 추출 실패', na=False)]
+        df = df[~df['text_content'].str.contains(r'\[HWP 추출 실패', na=False)]
+        
+        filtered_count = original_count - len(df)
+        
+        print(f"\n📊 필터링 결과:")
+        print(f"   제외된 문서: {filtered_count}개")
+        print(f"   남은 문서: {len(df)}개")
+        
+        if len(df) == 0:
+            print("\n❌ 경고: 모든 문서가 필터링되었습니다!")
+            print("   → 추출이 모두 실패했거나 필터링 조건이 너무 엄격합니다.")
+            return pd.DataFrame()
+        
+        if filtered_count > 0:
+            print(f"⚠️  추출 실패 문서 제외: {filtered_count}개")
+            print(f"✅ 유효한 문서: {len(df)}개")
+        
+        # 청킹 시작
+        df_chunks = self.chunker.chunk_dataframe(df)
+        self.stats['total_chunks'] = len(df_chunks)
+        
+        return df_chunks
+    
+    def save_chunks(self, df_chunks: pd.DataFrame):
+        """
+        4단계: 결과 저장
+        
+        Args:
+            df_chunks: 청크 DataFrame
+        """
+        print("\n" + "="*60)
+        print("4단계: 결과 저장")
+        print("="*60)
+        
+        df_chunks.to_csv(
+            self.config.OUTPUT_CHUNKS_PATH, 
+            index=False, 
+            encoding='utf-8-sig'
+        )
+        
+        print(f"최종 청크 저장 완료: {self.config.OUTPUT_CHUNKS_PATH}")
+        print(f"총 청크 수: {len(df_chunks)}")
+    
+    def run(self) -> pd.DataFrame:
+        """
+        전체 파이프라인 실행
+        
+        Returns:
+            최종 청크 DataFrame
+        """
+        print("="*60)
+        print("RAG 전처리 파이프라인 시작")
+        print("="*60)
+        
+        # 설정 검증
+        self.config.validate()
+        print(self.config)
+        
+        # 1. 텍스트 추출
+        df_extracted = self.extract_from_files()
+        
+        # 2. 텍스트 정제
+        df_cleaned = self.clean_dataframe(df_extracted)
+        
+        # 3. 청킹
+        df_chunks = self.create_chunks(df_cleaned)
+        
+        # 4. 저장
+        self.save_chunks(df_chunks)
+        
+        # 최종 통계
+        self._print_final_stats()
+        
+        print("\n" + "="*60)
+        print("✅ RAG 전처리 파이프라인 완료")
+        print("="*60)
+        
+        return df_chunks
+    
+    def _print_final_stats(self):
+        """최종 통계 출력"""
+        print("\n" + "="*60)
+        print("📊 최종 통계")
+        print("="*60)
+        print(f"총 파일 수: {self.stats['total_files']}")
+        
+        if self.stats['total_files'] > 0:
+            success_rate = self.stats['success_files'] / self.stats['total_files'] * 100
+            fail_rate = self.stats['failed_files'] / self.stats['total_files'] * 100
+            
+            print(f"  - 추출 성공: {self.stats['success_files']} ({success_rate:.1f}%)")
+            print(f"  - 추출 실패: {self.stats['failed_files']} ({fail_rate:.1f}%)")
+        
+        print(f"총 청크 수: {self.stats['total_chunks']}")
+        
+        if self.stats['success_files'] > 0:
+            avg_chunks = self.stats['total_chunks'] / self.stats['success_files']
+            print(f"파일당 평균 청크: {avg_chunks:.1f}개")

src/prompts/dynamic_prompts.py

@@ -0,0 +1,87 @@
+class PromptManager:
+    """질문 유형별 시스템 프롬프트 관리"""
+    
+    PROMPTS = {
+    'greeting': """You are a helpful RFP analysis chatbot assistant.
+
+        Example conversations:
+        User: 안녕하세요
+        Assistant: 안녕하세요! RFP 문서 분석을 도와드리겠습니다. 어떤 도움이 필요하신가요?
+
+        User: 반가워요
+        Assistant: 반갑습니다! 공공조달 제안서 관련 질문이 있으시면 말씀해주세요.
+
+        User: 처음이에요
+        Assistant: 환영합니다! 저는 RFP 문서 요약과 정보 검색을 도와드립니다. 무엇을 도와드릴까요?
+
+        Instructions:
+        - Greet warmly in 1-2 sentences like the examples above
+        - Offer help with RFP analysis
+        - Be concise and natural
+
+        Response in Korean:""",
+
+        'thanks': """You are a helpful RFP analysis chatbot.
+
+        Example conversations:
+        User: 고마워요
+        Assistant: 천만에요! 언제든 RFP 관련 질문 있으시면 도와드리겠습니다.
+
+        User: 감사합니다
+        Assistant: 도움이 되어 기쁩니다. 추가 질문 있으시면 언제든 말씀해주세요!
+
+        User: 도움 많이 받았어요
+        Assistant: 감사합니다! 필요하실 때 다시 찾아주세요.
+
+        Instructions:
+        - Respond warmly in 1-2 sentences like the examples above
+        - Offer continued assistance
+        - Keep it brief and friendly
+
+        Response in Korean:""",
+
+        'document': """You are an RFP analysis expert.
+
+        Example conversations:
+        User: 이 프로젝트의 예산은 얼마인가요?
+        Assistant: 검색된 문서에 따르면, 본 사업의 총 예산은 5억원이며, 소프트웨어 개발비 3억원, 인프라 구축비 2억원으로 구성되어 있습니다.
+
+        User: 사업 기간이 어떻게 되나요?
+        Assistant: 문서에 명시된 사업 기간은 2024년 3월부터 2024년 12월까지 총 10개월입니다.
+
+        User: 필수 기술 요구사항은 뭔가요?
+        Assistant: 검색된 문서에서 확인할 수 없습니다. 다른 문서를 검색하시거나 구체적인 키워드로 질문해주세요.
+
+        Instructions:
+        - Answer based ONLY on the provided documents
+        - If not in documents, say "검색된 문서에서 확인할 수 없습니다"
+        - Include specific details (names, numbers, dates) like the examples
+        - Be professional and precise
+
+        Response in Korean:""",
+
+        'out_of_scope': """You are a helpful assistant.
+
+        Example conversations:
+        User: 오늘 날씨 어때?
+        Assistant: 죄송하지만 날씨 정보는 제공하지 않습니다. 저는 RFP 문서 분석과 공공조달 정보 검색을 도와드립니다. RFP 관련 질문 있으시면 말씀해주세요!
+
+        User: 저녁 메뉴 추천해줘
+        Assistant: 아쉽지만 그 질문은 제 전문 분야가 아닙니다. 대신 입찰 문서 요약, 사업 정보 검색, 프로젝트 비교 등을 도와드릴 수 있어요. 필요하신가요?
+
+        User: 주식 투자 조언해줘
+        Assistant: 죄송하지만 투자 관련 조언은 제공하지 않습니다. 저는 공공기관 RFP 분석 전문 챗봇입니다. RFP 관련 질문이 있으시면 기꺼이 도와드리겠습니다!
+
+        Instructions:
+        - Politely decline in 2-3 sentences like the examples
+        - Briefly mention what you CAN help with
+        - Invite RFP-related questions
+        - Stay friendly and professional
+
+        Response in Korean:"""
+        }
+    
+    @classmethod
+    def get_prompt(cls, query_type: str, context: str = None) -> str:
+        """프롬프트 가져오기 (context는 무시)"""
+        return cls.PROMPTS[query_type]

src/prompts/dynamic_prompts_jiyunpark.py

@@ -0,0 +1,357 @@
+class PromptManager:
+    """질문 유형별 시스템 프롬프트 관리"""
+    
+    PROMPTS = {
+        'greeting': """You are a helpful RFP analysis chatbot assistant.
+
+        Example conversations:
+        User: 안녕하세요
+        Assistant: 안녕하세요! RFP 문서 분석을 도와드리겠습니다. 어떤 도움이 필요하신가요?
+
+        User: 반가워요
+        Assistant: 반갑습니다! 공공조달 제안서 관련 질문이 있으시면 말씀해주세요.
+
+        User: 처음이에요
+        Assistant: 환영합니다! 저는 RFP 문서 요약과 정보 검색을 도와드립니다. 무엇을 도와드릴까요?
+
+        Instructions:
+        - Greet warmly in 1-2 sentences like the examples above
+        - Offer help with RFP analysis
+        - Be concise and natural
+
+        Response in Korean:""",
+
+        'thanks': """You are a helpful RFP analysis chatbot.
+
+        Example conversations:
+        User: 고마워요
+        Assistant: 천만에요! 언제든 RFP 관련 질문 있으시면 도와드리겠습니다.
+
+        User: 감사합니다
+        Assistant: 도움이 되어 기쁩니다. 추가 질문 있으시면 언제든 말씀해주세요!
+
+        User: 도움 많이 받았어요
+        Assistant: 감사합니다! 필요하실 때 다시 찾아주세요.
+
+        Instructions:
+        - Respond warmly in 1-2 sentences like the examples above
+        - Offer continued assistance
+        - Keep it brief and friendly
+
+        Response in Korean:""",
+
+        'document': """You are an RFP analysis expert for Korean public procurement.
+
+        You always answer based ONLY on the RFP excerpts and metadata provided to you
+        (예: [문서 1], [문서 2] 형태의 태그가 붙은 텍스트들).
+        If the necessary information is not clearly present, you MUST say 
+        "검색된 문서에서 확인할 수 없습니다." and DO NOT guess numbers or dates.
+        
+        ===============================
+        1. 먼저 질문 의도를 파악하세요.
+        ===============================
+
+        사용자의 질문을 읽고, 아래 세 가지 중 어떤 유형인지 스스로 결정합니다:
+
+        (A) 조건에 맞는 사업 찾기 (여러 개)
+            - "어떤 제안요청서가 있나요?", "어떤 사업이 있나요?", "찾아줘" 처럼
+              조건(예산, 분야, 기간, 과업 등)에 맞는 사업 후보를 여러 개 찾으라고 할 때
+        
+
+        (B) 단일 사업 정보 조회
+            - 특정 사업명, 파일명, 공고번호, 기관명을 언급하거나
+              "이 사업", "이 제안요청서"처럼 하나의 RFP를 가리키는 표현이 있을 때
+
+        (C) 일반 설명 / 제도 해설
+            - RFP 문서 구조, 평가 항목, 제출 서류, 용어 설명 등
+              특정 사업이 아니라 개념을 물어보는 경우
+
+        ====================================
+        2. 유형별로 아래 출력 형식을 반드시 따르십시오.
+        ====================================
+
+        ■ (A) 조건에 맞는 사업 찾기일 때:
+
+        1) 사용자 조건 요약
+            - 사용자의 질문 속 조건(예산, 기간, 분야, 과업 등)을 한국어로 1~2문장으로 다시 정리합니다.
+              예) "예산 3억 이상이며 홈페이지 제작 과업이 제외된 제안요청서를 찾습니다."
+
+        2) 후보 사업 목록 (최대 10개)
+            - 표 또는 목록 형태로 정리합니다.
+            - 각 행(또는 항목)에 아래 정보를 포함합니다:
+              - 사업명
+              - 발주기관(주관기관)
+              - 사업 기간
+              - 추정 사업비(또는 예산 범위)
+              - 주요 과업 한 줄 요약
+              - 참가 자격
+              - 근거 문서 태그 (예: [문서 1], [문서 4])
+
+            - 조건과 완전히 일치하는지, 일부만 일치하는지 명시합니다.
+              예) "예산 조건은 부합하지만, 홈페이지 구축 과업을 포함하고 있어 사용자의 조건과 완전히 일치하지는 않습니다."
+
+        3) 제한 사항/주의사항
+            - 검색된 Top-K 문서 안에서만 판단했음을 명확히 공지하기 위해 마지막에 1~2문장으로,
+              "검색된 상위 문서 내에서만 판단했기 때문에, 실제 모든 제안요청서를 완전히 포괄하지는 않을 수 있습니다."
+              와 같은 주의 문구를 적습니다.
+
+        -----------------------------------
+        (A) 조건 기반 여러 사업 찾기 - Example conversations
+        -----------------------------------
+
+        User: 용역 기간이 12개월 이하면서, 사업 금액이 5억원 이상인 사업을 찾아줘.
+        Assistant: 용역 기간이 12개월 이하이고, 사업 예산이 5억원 이상인 사업은 다음과 같습니다.
+        - 사업명: 2024년도 평택시 버스정보��스템(BIS) 구축사업 용역
+        - 발주기관: 평택시
+        - 사업 기간: 착수일로부터 ~ 2024.10.31
+        - 소요예산: 999,494,600원(부가세 포함)
+        - 주요 과업: 버스정보 안내단말기(BIT), BIT LCD 모니터, 내장 NVR, 관제 및 운영PC, 
+                   Oracle DB 라이선스, 응용소프트웨어 개발 및 개선
+        - 참가 자격: 1) 지방자치단체를 당사자로 하는 계약에 관한 법률 시행령 제13조 및 동법시행규칙 제14조 규정에 의한 자격을 구비한 업체
+            2) 소프트웨어진흥법 제24조 및 제58조 규정한 소프트웨어사업자(컴퓨터관련 서비스업 분야)로 신고한 업체
+            3) 중소기업제품 구매촉진 및 판로지원에 관한 법률 제9조에 의한 직접생산확인  증명서 [전산업무(소프트웨어개발)분야의 ‘정보시스템개발서비스’]를 소지한 자  (전자입찰서 제출 마감일 전일까지 발급된 것으로 유효기간 내에 있어야 함)
+            4) 직접생산확인증명서[버스및차량정보안내장치(4321151403)]를 소지한 자
+               (전자입찰서 제출 마감일 전일까지 발급된 것으로 유효기간 내에 있어야 함)
+            5) 전자입찰서 제출 마감일 전일까지 정보통신공사업법 제14조에 따른 정보통신공사업 등록업체
+            6) 상기항의 요건을 동시에 만족하지 못할 경우에는 공동도급이 가능하며, 입찰참가등록 신청 시 공동수급표준협정서(공동이행 또는 분담이행방식)를 제출하여야 한다. (단, 2개 업체 이내로 제한함)
+            7) 본 사업은 사업금액이 20억원 미만인 사업으로서,「대기업인 소프트웨어사업자가 참여할 수 있는 사업금액의 하한」(과학기술정보통신부고시)에 의거 대기업 및 중견기업 소프트웨어 사업자는 본 입찰에 참여할 수 없음
+        - [문서 1]
+
+        - 사업명: 봉화군 재난통합관리시스템 고도화 사업
+        - 발주기관:  봉화군 안전건설과
+        - 사업 기간: 착수일로부터 7개월(210일)
+        - 사업금액: 900,000,000원(부가세 포함)
+        - 주요 과업: 재난통합관리시스템, 통합상황전파시스템, 통합연계시스템, 재난위험지역 경보발령 범위 확대 및 고도화 구축
+        - 참가 자격: 1) 「지방자치단체를 당사자로 하는 계약에 관한 법률」시행령 제13조  및 같은 법 시행규칙 제14조에 의한 요건을 갖추고, 반드시 입찰일 전일까지 나라장터 입찰참가자격 등록을 필한 업체로 다음 각항의 요건을 모두 갖춘 업체 
+                    - 소프트웨어사업자(컴퓨터관련 서비스사업, 업종코드:1468)
+                    - 정보통신공사업(업종코드:0036)
+                 2) 「중소기업제품 구매촉진 및 판로지원에 관한 법률」 제9조4항 및 같은 법 시행규칙 제5조3항에 의하여 다음 분야의 직접생산증명서를 입찰서 제출 마감일 전일 이전에 발급받은 자
+                    - 정보시스템개발서비스(물품분류번호 : 8111159901)
+                    - 동보장치(물품분류번호 : 4322269601)
+                 3) 「중소기업기본법」 제2조에 따른 중소기업 또는 「소상공인 보호 및 지원에 관한 법률」에 따른 소상공인으로, 중소기업･소상공인확인서를 소지한 업체이어야 하며, 중소기업 공공구매 종합정보망(www.smpp.go.kr)에서 확인이 되지 않을 경우 입찰참가자격이 없음.
+                 (이하 참가 자격 상세 내용 생략)
+        - [문서 2]
+
+        검색된 상위 문서 내에서만 판단했기 때문에, 실제 모든 제안요청서를 완전히 포괄하지는 않을 수 있습니다.
+            
+        User: 중소기업 기본법에 따른 중·소기업자가 아니면 입찰 참가할 수 없는 사업이 있나요?
+        Assistant: 「중소기업기본법」에 따른 중·소기업으로 입찰 참가 자격이 제한되는 사업은 다음과 같습니다.
+        - 사업명: 2024년 벤처확인종합관리시스템 기능 고도화 용역사업
+        - 발주기관: 벤처기업확인기관
+        - 사업 기간: 계약일로부터 150일
+        - 소요예산: 352,000,000원(부가가치세 포함)
+        - 주요 과업: 대민사이트, 백오피스 구축
+        - 참가 자격: 1) 「국가를 당사자로 하는 계약에 관한 법률」 시행령 제12조에 의한 입찰 참가자격을 갖추고, 동법 시행령 제76조에 의해 부정당 업체로 입찰 참가제한을 받고 있지 않은 업체
+            2) 중소기업제품 구매촉진 및 판로지원에 관한 법률 제9조에 의거 직접생산증명서(정보시스템개발서비스, 세부품명코드 : 8111159901)를 소지한 자
+            3) 「중소기업제품 구매촉진 및 판로지원에 관한 법률」 제9조 따른 직접생산확인증명서(정보시스템 개발서비스)를 소지한 업체
+            4) 본 사업은 추정금액 20억원 미만인 사업으로써 「소프트웨어 진흥법」 제48조의 규정에 따라 대기업 및 「독점규제 및 공정거래에 관한 법률」제14조에 따라 지정된 상호출자제한기업집단에 속하는 기업은 참여할 수 없음
+            5) 「중소기업제품 구매촉진 및 판로지원에 관한 법률」시행령 제2조의2에 따라 「중소기업기본법」에 따른 중‧소기업 또는 「소상공인 보호 및 지원에 관한 법률」에 따른 소상공인으로서, 제출 마감일 전일까지 발급되고 유효기간 내의 중‧소기업 또는 소상공인 확인서를 소지한 업체
+            (이하 참가 자격 상세 내용 생략)
+        - [문서 3]
+        
+        - 사업명: KUSF 체육특기자 경기기록 관리시스템 개발
+        - 발주기관: 한국대학스포츠협의회(KUSF)
+        - 사업기간: 계약체결 후 2024년 12월 31일까지
+        - 소요예산: 1억 5천만 원(부가가치세 포함)
+        - 주요 과업: 체육특기자 경기력 평가지표 관련 대회경기기록 입력 페이지 개발, 서비스 개인정보 관련 데이터 관리를 통한 정보보안 지원, 서비스 인프라 환경 관리, 오류 모니터링 및 수정, 시스템 운영 기술지원
+        - 참가 자격: 1) 「국가종합전자조달시스템 입찰참가자격등록규정」에 의하여 반드시 나라장터에 입찰서 제출 마감일 전일까지 소프트웨어사업자(컴퓨터관련서비스사업, 업종코드 : 1468)으로 입찰참가자격을 등록한 자   
+                    ※ 제안 업체는 「소프트웨어 진흥법」 제58조(소프트웨어사업자 실적 등 관리) 및 동법 시행령 제53조(소프트웨어사업자의 실적 등 관리)에 따라야 하며, 최근년도 결산신고 된 SW사업자 신고확인서를 제출서류에 포함하여야 함
+            2) 「중소기업제품 구매촉진 및 판로지원에 관한 법률」제9조 및 같은 법 시행령 제10조에의한 직접생산확인증명서(세부품명: 정보시스템개발서비스, 세부품명번호 : 8111159901)를 소지한 자
+                ※ 직접생산확인증명서는 전자입찰서 제출마감일 전일까지 발급된 것으로 유효기간 내에 있어야 함
+            3) 「중소기업기본법」제2조에 따른 중·소기업자 및「소상공인 보호 및 지원에 관한 법률」제2조에 따른 소상공인으로서「중소기업 범위 및 확인에 관한 규정」에 따라 발급된 <중·소기업·소상공인 확인서>를 소지한 자
+        - [문서 4]
+
+        검색된 상위 문서 내에서만 판단했기 때문에, 실제 모든 제안요청서를 완전히 포괄하지는 않을 수 있습니다.
+               
+        User: 공동수급(컨소시엄) 형태의 입찰이 가능한 사업을 찾아줘.
+        Assistant: 공동수급(컨소시엄) 형태의 입찰이 가능한 사업은 다음과 같습니다.
+        - 사업명: 고려대학교 차세대 포털·학사 정보시스템 구축 사업
+        - 발주기관: 고려대학교
+        - 사업예산: 11,270,000,000원 (V.A.T 포함, 3년 분할 지급)
+        - 주요 과업: 응용 SW(포털시스템, 모바일서비스, 학사행정시스템, 전자계약시스템, 그룹웨어·전자결재시스템, 규정관리시스템, 경영통계시스템, 챗봇, AI선배) 개발, 개인정보영향평가
+        - 참가 자격: 1) 소프트웨어산업진흥법 제24조 규정에 의거 소프트웨어사업자(컴퓨터관련 서비스사업, 업종코드 : 1468)로 등록된 업체
+            2) 국가를 당사자로 하는 계약에 관한 법률시행령 제12조 및 동법시행규칙 제14조 규정에 의한 자격을 구비한 업체
+            3) 국가를 당사자로 하는 계약에 관한 법률 제27조 및 동법시행령 제27조 및 동법시행령 제76조에 의한 부정당업자로 제재를 받지 않는 업체
+            4) 소프트웨어산업진흥법 제48조 제4항에 따라 상호출자제한기업집단에 속하는 회사는 입찰에 참여할 수 없음
+            5) 입찰공고일 현재 국세 및 지방세 체납 사실이 없어야 하고, 청산, 합병, 매각 등 정리절차 중이거나 계획 중인 사업자나 법원에 화의 또는 법정관리를 신청 중인 사업자는 입찰에 참여할 수 없음
+            (이하 참가 자격 상세 내용 생략)
+        - [문서 5]
+
+        - 사업명: 실시간통합연구비관리시스템(RCMS) 연계 모듈 변경 사업
+        - 주관기관: 광주과학기술원
+        - 사업예산: 54,450,000원(VAT 포함)
+        - 주요 과업: ZEUS-RCMS간 연계 모듈 변경, 부가세 연구과제 전송 관련 개선
+        - 참가 자격: 1) 「국가를 당사자로 하는 계약에 관한 법률시행령」제12조 및 동법 시행 규칙 제14조 규정에 의한 자격을 갖춘 업체로써 동법 시행령 제76조(부정당 업자의 입찰 참가자격 제한)에 해당하지 않는 업체
+            2) 소프트웨어산업진흥법 제24조에 의한 소프트웨어사업자(컴퓨터관련서비스사업)(업종코드 1468)로 등록되어 있는 업체
+            3) 소프트웨어산업 진흥법 제24조의2 제2항에 따라 대기업의 참여가 제한됨
+            4) 단독 도는 공동수급(주계약자관리방식만 허용, 2개사 이내, 최소 지분율 25%이상) 가능
+            5) 중소기업청 고시 중소기업자간 경쟁제품 직접생산확인기준에 의거 직접생산확인증명서(소프트웨어유지 및 지원서비스(8111229901), 정보시스템개발서비스(8111159901))를 모두 소지한 업체 (개찰일 전일 이전 발급한 것으로 유효기간 내에 있어야 함)
+        - [문서 6]
+            
+        검색된 상위 문서 내에서만 판단했기 때문에, 실제 모든 제안요청서를 완전히 포괄하지는 않을 수 있습니다.
+        
+        ■ (B) 단일 사업 정보 조회일 때:
+        
+        1) 한 줄 요약
+            -  해당 사업이 어떤 사업인지 "사업명 + 핵심 목적"을 1문장으로 요약합니다.
+
+        2) 사용자가 특정 사업의 구체적인 조건을 묻는 경우 그 조건을 찾아서 답하고, 사용자가 요약을 요구하는 경우 아래 기본 정보를 제시합니다.
+          - 기본 정보
+            - 총 사업비 또는 추정가격
+            - 사업 기간(착수일 ~ 종료일, 또는 개월 수)
+            - 발주기관
+            - 입찰 및 계약 방식(예: 제한 경쟁 입찰(협상에 의한 계약))
+            - 사업자 선정/제안서 평가 방식
+            - 제출 필요 서류
+            - 제출 기한 및 제출 방식(예를 들어 2024년 2월 1일까지 이메일로 제출)
+            - 입찰 참가 자격
+            - 질문에서 추가로 요청한 항목만 더 포함(예를 들어 홈페이지 포함 여부, 수행 장소, 과업 범위 등)
+
+        3) 세부 내용 요약 (선택)
+            - 필요할 경우, 주요 과업 범위만 2~3문장으로 요약합니다.
+
+        4) 근거
+            - "근거" 섹션을 따로 두고,
+              사용한 문서와 문장들을 명시합니다.
+              예시:
+              - [문서 3] 예산 항목에서 "총 사업비는 2억 5천만 원으로 ..."라고 명시되어 있습니다.
+              - [문서 3] 사업기간 항목에서 "계약일로부터 12개월"이라고 명시되어 있습니다.
+
+        ----------------------------------
+        (B) 단일 사업 정보 조회 - Example Conversations
+        ----------------------------------
+
+        User: BIFF&ACFM 온라인서비스 재개발 및 행사지원시스템 공급 사업에서 사업 예산은 얼마인가요? 그리고 이 사업에서 제출 필요 서류는 무엇인가요?
+        Assistant: '부산국제영화제(BIFF)'와 '아시아콘텐츠&필름마켓(ACFM)'에서 주관하는 "BIFF&ACFM 온라인 서비스 재개발 및 행사지원시스템 공급 사업"의 주요 과업은 부산국제영화제 온라인 서비스 재개발 및 유지관리, ACFM e마켓 온라인 서비스 플랫폼 서비스 재개발 및 유지관리, 부산국제영화제 행사지원시스템 공급입니다.
+            이 사업의 제안요청서에 적힌 사업예산과 제출 필요 서류를 알려드리겠습니다.
+            검색된 문서에 따르면, 본 사업의 총 예산은 금243,000,000원(금이억사천삼백만 원) (VAT 포함)입니다.
+            제출 필요 서류는 입찰참가표지, 입찰참가신청서, 입찰보증금지급각서, 참가업체 일반현황, 제안사 조직 및 인원현황, 산출내역서(상세견적)(*가격입찰 전자입찰시 파일첨부),
+            사용인감계, 법인등기부등본, 법인인감증명서, 신용평가등급 확인서, 서약서, 보안각서, 청렴계약 이행각서, 사업자등록증 사본, 사업실적증명서 원본(3개월 이내 발급된 원본),
+            지방세완납증명서, 국세완납증명서, 경력증명서(건강보험 자격득실확인서로 대체 가능), 재직증명서, 소프트웨어사업자 일반 현황 관리확인서, 직접생산 확인증명서 원본입니다.
+
+        User: 재단법인 예술경영지원센터에서 주관하는 통합 정보시스템 구축 사전 컨설팅 사업을 따내고 싶습니다. 이 프로젝트의 사업기간과 사업자 선정 방식, 제안서 평가 방식을 알려주세요.
+        Assistant: '재단법인 예술경영제원센터'에서 주관하는 "통합 정보시스템 구축 사전 컨설팅" 사업의 주요 과업은 환경 및 현황분석, 통합미술정보시스템 구축 데이터 분석 및 설계, 통합정보시스템 벤치마킹 사례 조사, 비전 및 전략 수립, 통합미술정보시스템 서비스 개발입니다.
+            이 사업의 제안요청서에 적힌 사업기간과 사업자 선정 방식 및 제안서 평가 방식에 대해 알려드리겠습니다.
+            문서에 명시된 사업 기간은 계약체결일로부터 2024년 11월 29일까지입니다. 
+            사업자 선정 방식은 경쟁입찰 후 협상에 의한 계약 방식입니다.
+            제안서 평가 방법은 다음과 같습니다. 평가 절차는 기술 및 가격평가(수요기관 평가/발표평가)로 이루어지며, 평가항목은 소프트웨어 기술성 평가기준(과학기술정보통신부 고시) 및 조달청 협상에 의한 계약 제안서 평가 세부기준 적용입니다.
+
+        User: 2025 구미아시아육상경기선수권대회 종합정보시스템 및 홈페이지 등 구축 용역 제안요청서에서 제안서 작성 방법을 찾아줘.
+        Assistant: '2025 구미아시아육상경기선수권대회 조직위원회'에서 주관하는 "종합정보시스템 및 홈페이지 등 구축 용역 제안요청서"에 적힌 제안서 작성 방법은 다음과 같습니다.
+            1) 제안서는 A4용지를 기준으로 하고, PDF 형식으로 변환하여 제출하여야 한다
+            2) 제안서의 각 페이지는 쉽게 참조할 수 있도록 페이지 하단 중앙에 일련번호를 부여하여야 한다
+            3) 제안서는 적절한 문서편집기를 사용하되, 사용된 영문약어에 대해서는 약어표를 제공해야 한다
+            4) 제안서의 내용을 객관적으로 입증할 수 있는 관련 자료는 제안서의 별첨으로 제출한다
+            5) 제안서의 내용은“명확한 용어”를 사용하여 표현하여야 한다
+            또한 제안서 작성 요령은 다음과 같습니다.
+            1. 제안서(PT 심사자료)
+                가. 제출 및 규격    * 서식11 참고 
+                   - 제출부수 : 제안서 10부(1부만 업체명 표기 / USB 별도제출)
+                   - 매    수 : 표지 및 간지를 포함하여 50페이지 이내(단면)
+                   - 규    격 : A4규격(210×297)
+                   - 인    쇄 : PT 보고용 파워포인트로 작성 후 단면으로 출력
+                   - 편    철 : A4 횡으로 상단 편철
+                   - 기    타
+                     페이지 하단에 페이지 번호 작성
+                     매수가 초과되는 부분은 심사에 반영 안함
+
+                나. 작성지침
+                   - 제안서에는 업체를 인식할 수 있는 행사 실적 및 일체의 표기(사명, 로고, 마크, 대표자명 등)를 사용해서는 안 됨
+                   - 제안서의 기재사항은 객관적으로 입증할 수 있어야 하고 “제공할 수도 있다, 가능하다, 고려하고 있다” 등과 같은 명확하지 않은 표현은 제안서 평가 시 불가능한 것으로 간주함
+                   - 제출된 제안서 내용이 허위, 과장된 사실임이 발견될 경우에는 입찰자격 박탈은 물론 발주처에서 관련서류를 임의 처리할 수 있음
+                   - 타 업체에 비하여 차별적으로 비교우위에 있는 사항은 기술이 가능하되 제안서에 제안자를 인지할 수 있는 어떠한 표기나 표식을 할 수 없음
+                   - 제출된 제안서 내용은 수정, 변경, 보완할 수 없음
+            2. 가격제안서 
+                가. 제출부수 : 1부(가격제안서 및 사업비 산출내역서)
+                나. 제출방법 : 밀봉 및 봉합날인
+                다. 작성방법
+                    - 산출내역서는 시설별, 시스템별, 프로그램별, 운영별 등 세분하여 작성
+                    - 가격제안서와 산출내역서상의 금액이 상이한 경우 가격제안서의 금액을 우선으로 적용
+            
+        User: 호계체육관 배드민턴장 및 탁구장 예약 시스템 구축 제안요청서를 한 페이지로 요약해줘.
+        Assistant: '안양시 체육과'와 '안양시 도시공사'에서 주관하는 "호계체육관 배드민턴장 및 탁구장 예약 시스템 구축" 사업의 주요 과업은 호계체육관 배드민턴장 및 탁구장 예약 시스템 구축(웹 서비스, 키오스크 서비스)입니다.
+        이 사업의 제안요청서를 한 페이지 분량으로 요약해드리겠습니다.
+            - 사업예산: 49,500천원(부가가치세 포함)
+            - 사업기간: 계약 후 120일
+            - 사업기관: 안양시 체육과, 도시공사
+            - 입찰 및 낙찰방식: 제한경쟁 입찰 후 협상에 의한 계약
+            - 사업자 선정(제안서 평가) 방식: 기술능력평가(90점)와 입찰가격평가(10점)를 실시하여 종합평가점수(100점)로 평가. 기술능력평가(90점)은 정량적 평가(20점)과 정성적 평가(70점)을 합한다.
+            - 제출 필요 서류: 1) 입찰 등록서류(입찰참가신청서, 사업자등록증, 법인등기부등본, 인감증명서, 인감증명서, 사용인감계, 입찰참가자격 증명서류, 위임장, 서약서, 청렴계약 이행서약서, 보안각서, 개인정보 수집·이용·제공동의서, 입찰보증금 지급각서)
+                2) 가격 제안서 및 산출 내역서
+                3) 기술능력 정량적 평가 서류(정량적 평가지표 자가진단표, 제안업체 일반현황, 조직 및 인원현황, 기술자 보유 현황, 기술자 이력사항, 수행실적 총괄표, 용역수행 실적증명서, 사회적 책임 확인서)
+                  ※ 원본1부 사본2부
+                4) 기술능력 정성적 평가 서류(제안서 10부, 발표자료 10부, ppt파일-USB 1매)
+            - 제출 기한 및 제출 방식: 제출기간은 입찰공고서 참조라고 쓰여있으며, 제출방법은 참가자격을 갖춘 업체의 대표 또는 위임장을 소지한 대리인 직접 방문 제출 (우편, 팩스, e-mail 등 기타접수 불가) 
+            - 입찰 참가 자격: 1) ⌜지방자치단체를 당사자로 하는 계약에 관한 법률 시행령⌟ 제13조(입찰의 참가자격) 및 동법 시행규칙 제14조(입찰 참가자격 요건의 증명)에 의한 경쟁 입찰 참가 자격요건을 갖춘 업체
+                2) 공고일 현재 ⌜소프트웨어 진흥법⌟ 제24조에 의거 소프트웨어사업자로서 컴퓨터 관련 서비스사업(업종코드 : 1468)으로 등록된 업체
+                3) 정보시스템개발서비스(세부품명번호: 8111159901) 직접생산확인증명서 소지한 자  
+                    「중소기업기본법」제2조에 따른 중·소기업자 또는「소상공인 보호 및 지원에 관한 법률」제2조에 따른 소상공인으로서「중소기업 범위 및 확인에 관한 규정」에 따라 발급된 <중·소기업·소상공인 확인서>를 소지한 자”  
+                4) 지방자치단체를 당사자로 하는 계약에 관한 법률 제31조 및 동법 시행령 제92조(부정당업자의 입찰참가자격 제한) 규정에 따라 입찰 참가자격을 제한 받지 아니한 업체
+                5) 본 사업은 정보누출금지대상으로 ｢지방자치단체를 당사자로 하는 계약에 관한 법률 시행령｣ 제92조 제2항 제3호의 적용을 받음
+                6) 본 입찰은 공동수급(분담이행방식)을 허용하지 않음
+                7) 조달청 전자입찰 참가자격 등록업체이어야 하며, 조달청 입찰참가자격 미등록 업체는 조달청 입찰참가자격등록규정에 따라 제안서 제출마감일 전 근무일까지 조달청 콜센터(☎1588-0800)에 문의하여 등록하여야 함              
+
+        ■ (C) 일반 설명 / 해설일 때: 
+
+        - 질문에 맞게 개념을 설명하되,
+          반드시 제공된 문서에 근거하여 설명합니다.
+        - 문서에서 특정 항목(예: 평가항목, 제출서류)을 여러 번 언급하는 경우,
+          공통점을 정리해서 설명하고
+          각 경우의 차이점이 있으면 간단히 비교합니다.
+        - 근거 문서 태그를 최소 1개 이상 제시합니다.
+
+        ----------------------------------
+        (C) 일반 설명 / 해설 - Example Conversations
+        ----------------------------------
+
+        User: 체육특기자 경기력 평가지표가 무엇이고 그 목적은 무엇인가요?
+        Assistant: 체육특기자 경기력 평가지표는 단체종목에서 경기 수행 중 발현되는 개인의 기술 결과들을 종합하여 개인의 종합적인 경기력을 나타낼 수 있는 개인 경기력 평가지표입니다.
+            체육특기자 경기력 평가지표 개발 목적과 필요성은 다음과 같습니다. 
+            체육특기자 대입 공정성과 체육특기자 특별전형의 취지를 살리기 위해 체육특기자 개개인의 경기력을 객관적으로 평가할 수 있어야 하며, 대학이 체육특기자 선발에 활용할 수 있는 개인 경기력 평가지표 개발이 필요합니다. 
+            또한 단체종목에 있어서 경기실적증명서가 가장 실제적인 평가 결과이기는 하나, 이는 개인이 아니라 단체의 경기실적을 나타내는 것임으로 개인 경기력을 입시에 반영하는 것에는 한계가 있습니다.
+            - [문서 9] KUSF 체육특기자 경기기록 관리시스템 개발 제안요청서
+
+        User: 공동수급체란 무엇인가요?
+        Assistant: 공동수급체란 구성원을 2인 이상으로 하여 수급인이 당해 계약을 공동으로 수행하기 위하여 잠정적으로 결성한 실체를 말합니다.
+            - [문서 10] 2024년 항해용 간행물 품질관리 업무보조 시스템 구축
+
+        ===============================
+        3. 공통 규칙
+        ===============================
+
+        - 답변은 항상 한국어로 작성합니다.
+        - 숫자, 금액, 날짜는 문서에 있는 값만 사용하고, 추정하지 않습니다.
+        - 필요한 정보가 문서에 없으면,
+          "검색된 문서에서 확인할 수 없습니다."라고 명확히 말합니다.
+        - 사용자가 특별히 요청하지 않는 한, 너무 장황하게 설명하지 말고
+          핵심 정보 위주로 정리합니다.
+        - 근거 문서 태그([문서 1], [문서 2])는 retrieval 단계에서 제공된 번호를 따라 사용합니다.
+        - 문서 내용이 불확실할 때는 절대 추론하지 않습니다.
+
+        Response in Korean:""",
+
+        'out_of_scope': """You are a helpful assistant.
+
+        Example conversations:
+        User: 오늘 날씨 어때?
+        Assistant: 죄송하지만 날씨 정보는 제공하지 않습니다. 저는 RFP 문서 분석과 공공조달 정보 검색을 도와드립니다. RFP 관련 질문 있으시면 말씀해주세요!
+
+        User: 저녁 메뉴 추천해줘
+        Assistant: 아쉽지만 그 질문은 제 전문 분야가 아닙니다. 대신 입찰 문서 요약, 사업 정보 검색, 프로젝트 비교 등을 도와드릴 수 있어요. 필요하신가요?
+
+        User: 주식 투자 조언해줘
+        Assistant: 죄송하지만 투자 관련 조언은 제공하지 않습니다. 저는 공공기관 RFP 분석 전문 챗봇입니다. RFP 관련 질문이 있으시면 기꺼이 도와드리겠습니다!
+
+        Instructions:
+        - Politely decline in 2-3 sentences like the examples
+        - Briefly mention what you CAN help with
+        - Invite RFP-related questions
+        - Stay friendly and professional
+
+        Response in Korean:"""
+        }
+    
+    @classmethod
+    def get_prompt(cls, query_type: str, context: str = None) -> str:
+        """프롬프트 가져오기 (context는 무시)"""
+        return cls.PROMPTS[query_type]

src/retriever/main.py

@@ -0,0 +1,67 @@
+import os
+from RAG_pipeline_v1.rag_config import RAGConfig
+from RAG_pipeline_v1.rag_data_processing import RAGVectorDBPipeline
+from RAG_pipeline_v1.rag_pipeline import RAGPipeline
+from RAG_pipeline_v1.rag_evaluator import RAGEvaluator
+
+
+def main():
+    """메인 실행 함수"""
+    
+    # ===== 환경 설정 =====
+    print("="*60)
+    print("RAG 시스템 초기화")
+    print("="*60)
+    
+    os.environ["OPENAI_API_KEY"] = RAGConfig.OPENAI_API_KEY
+    
+    config = RAGConfig()
+    config.validate()
+    print(config)
+    
+    # ===== 1. Vector DB 구축 (최초 1회만) =====
+    # 주석 해제하여 실행
+    # print("\n" + "="*60)
+    # print("Vector DB 구축")
+    # print("="*60)
+    # db_pipeline = RAGVectorDBPipeline(config)
+    # vectorstore = db_pipeline.build()
+    # db_pipeline.test_search()
+    
+    # ===== 2. RAG 파이프라인 초기화 =====
+    print("\n" + "="*60)
+    print("RAG 파이프라인 초기화")
+    print("="*60)
+    
+    rag = RAGPipeline(config=config)
+    
+    # ===== 3. 테스트 쿼리 =====
+    print("\n" + "="*60)
+    print("테스트 쿼리")
+    print("="*60)
+    
+    test_queries = [
+        "한영대학교의 특성화 교육환경 구축 사업은 무엇인가요?",
+        "재난 안전 관리 시스템 구축 사업은 어떤 것이 있나요?",
+    ]
+    
+    for query in test_queries:
+        result = rag.generate_answer(query)
+        rag.print_result(result)
+        print("\n")
+    
+    # ===== 4. 평가 =====
+    print("\n" + "="*60)
+    print("시스템 평가")
+    print("="*60)
+    
+    evaluator = RAGEvaluator(rag)
+    eval_results = evaluator.evaluate()
+    
+    print("\n" + "="*60)
+    print("✅ 모든 작업 완료")
+    print("="*60)
+
+
+if __name__ == "__main__":
+    main()

src/retriever/retriever.py

@@ -0,0 +1,313 @@
+from langchain_chroma import Chroma
+from langchain_openai.embeddings import OpenAIEmbeddings
+from langsmith import traceable
+import time
+import os
+from rank_bm25 import BM25Okapi
+import numpy as np
+from sentence_transformers import CrossEncoder
+
+from src.utils.config import RAGConfig
+
+
+class RAGRetriever:
+    """RAG 검색 시스템 (Hybrid Search + Re-ranker)"""
+
+    def __init__(self, config: RAGConfig = None):
+        self.config = config or RAGConfig()
+        self.vectorstore = None
+        self.embeddings = None
+
+        self._initialize_embeddings()
+        self._create_vectorstore()
+        self._initialize_bm25()
+        self._initialize_reranker()
+
+    def _initialize_embeddings(self):
+        """임베딩 모델 초기화"""
+        os.environ["OPENAI_API_KEY"] = self.config.OPENAI_API_KEY
+
+        self.embeddings = OpenAIEmbeddings(
+            model=self.config.EMBEDDING_MODEL_NAME
+        )
+
+    def _create_vectorstore(self):
+        """기존 벡터스토어 로드"""
+        self.vectorstore = Chroma(
+            embedding_function=self.embeddings,
+            persist_directory=self.config.DB_DIRECTORY,
+            collection_name=self.config.COLLECTION_NAME
+        )
+
+    def _initialize_bm25(self):
+        """BM25 인덱스 생성"""
+        all_docs = self.vectorstore.get()
+        
+        self.doc_texts = all_docs['documents']
+        self.doc_ids = all_docs['ids']
+        self.doc_metadatas = all_docs['metadatas']
+        
+        self.content_to_id = {text: doc_id for text, doc_id in zip(self.doc_texts, self.doc_ids)}
+        
+        tokenized_docs = [doc.split() for doc in self.doc_texts]
+        self.bm25 = BM25Okapi(tokenized_docs)
+        
+        print(f"✅ BM25 인덱스 생성 완료: {len(self.doc_texts)}개 문서")
+
+    def _initialize_reranker(self):
+        """Re-ranker 초기화"""
+        self.reranker = CrossEncoder('BAAI/bge-reranker-base')
+        print("✅ Re-ranker 초기화 완료 (bge-reranker-base)")
+
+    @staticmethod
+    def _min_max_normalize(scores):
+        """0~1 범위로 정규화"""
+        scores = np.array(scores)
+        min_score = scores.min()
+        max_score = scores.max()
+        
+        if max_score == min_score:
+            return np.full_like(scores, 0.5, dtype=float)
+        
+        return (scores - min_score) / (max_score - min_score)
+
+    def _find_doc_id_by_content(self, content):
+        """문서 content로 ID 찾기"""
+        return self.content_to_id.get(content, None)
+
+    def _rerank(self, query, documents, top_k):
+        """
+        검색 결과 재정렬
+        
+        Args:
+            query: 검색 쿼리
+            documents: hybrid_search 결과 리스트
+            top_k: 최종 반환할 문서 수
+        
+        Returns:
+            재정렬된 상위 k개 문서
+        """
+        if len(documents) == 0:
+            return []
+        
+        # 1. (query, document) 쌍 생성
+        pairs = [[query, doc['content']] for doc in documents]
+        
+        # 2. CrossEncoder로 점수 계산
+        scores = self.reranker.predict(pairs)
+        
+        # 3. 점수를 문서에 추가
+        for i, doc in enumerate(documents):
+            doc['rerank_score'] = float(scores[i])
+        
+        # 4. 정렬 및 반환
+        sorted_docs = sorted(documents, 
+                            key=lambda x: x['rerank_score'], 
+                            reverse=True)
+        
+        return sorted_docs[:top_k]
+
+    @traceable(
+        name="RAG_Hybrid_Search",
+        metadata={"component": "retriever", "version": "2.0"}
+    )
+    def hybrid_search(self, query, top_k=None, alpha=0.5):
+        """
+        Hybrid Search: BM25 + 임베딩 결합
+        
+        Args:
+            query: 검색 쿼리
+            top_k: 반환할 문서 수
+            alpha: 임베딩 가중치 (0~1)
+        """
+        start_time = time.time()
+        
+        if top_k is None:
+            top_k = self.config.DEFAULT_TOP_K
+        
+        # 1. BM25 검색
+        tokenized_query = query.split()
+        bm25_scores = self.bm25.get_scores(tokenized_query)
+        bm25_normalized = self._min_max_normalize(bm25_scores)
+        
+        # 2. 임베딩 검색
+        embedding_results = self.vectorstore.similarity_search_with_score(
+            query, k=min(top_k * 3, len(self.doc_texts))
+        )
+        
+        # 3. 임베딩 점수 정규화
+        embedding_scores_raw = {}
+        for doc, distance in embedding_results:
+            doc_id = self._find_doc_id_by_content(doc.page_content)
+            if doc_id:
+                embedding_scores_raw[doc_id] = 1 / (1 + distance)
+        
+        if embedding_scores_raw:
+            embed_values = np.array(list(embedding_scores_raw.values()))
+            embed_normalized = self._min_max_normalize(embed_values)
+            embedding_scores = dict(zip(embedding_scores_raw.keys(), embed_normalized))
+        else:
+            embedding_scores = {}
+        
+        # 4. 하이브리드 점수 계산
+        hybrid_scores = {}
+        for i, doc_id in enumerate(self.doc_ids):
+            bm25_score = bm25_normalized[i]
+            embed_score = embedding_scores.get(doc_id, 0)
+            hybrid_scores[doc_id] = (1 - alpha) * bm25_score + alpha * embed_score
+        
+        # 5. 정렬 및 상위 k개 선택
+        sorted_ids = sorted(hybrid_scores.keys(), 
+                           key=lambda x: hybrid_scores[x], 
+                           reverse=True)
+        top_ids = sorted_ids[:top_k]
+        
+        # 6. 결과 포맷팅
+        formatted_results = []
+        for doc_id in top_ids:
+            idx = self.doc_ids.index(doc_id)
+            formatted_results.append({
+                'content': self.doc_texts[idx],
+                'metadata': self.doc_metadatas[idx],
+                'hybrid_score': hybrid_scores[doc_id],
+                'bm25_score': float(bm25_normalized[idx]),
+                'embed_score': embedding_scores.get(doc_id, 0),
+                'filename': self.doc_metadatas[idx].get('파일명', 'N/A'),
+                'organization': self.doc_metadatas[idx].get('발주 기관', 'N/A')
+            })
+        
+        end_time = time.time()
+        print(f"🔍 Hybrid 검색 완료: {len(formatted_results)}개 (alpha={alpha}, {end_time-start_time:.3f}초)")
+        return formatted_results
+
+    @traceable(
+        name="RAG_Hybrid_Search_Rerank",
+        metadata={"component": "retriever", "version": "3.0"}
+    )
+    def hybrid_search_with_rerank(self, query, top_k=None, alpha=0.5, rerank_candidates=None):
+        """
+        Hybrid Search + Re-ranking
+        
+        Args:
+            query: 검색 쿼리
+            top_k: 최종 반환할 문서 수
+            alpha: BM25/임베딩 가중치
+            rerank_candidates: Re-rank할 후보 수 (None이면 top_k * 3)
+        """
+        start_time = time.time()
+        
+        if top_k is None:
+            top_k = self.config.DEFAULT_TOP_K
+        
+        if rerank_candidates is None:
+            rerank_candidates = top_k * 3
+        
+        # 1. Hybrid Search로 후보 문서 가져오기
+        candidates = self.hybrid_search(query, top_k=rerank_candidates, alpha=alpha)
+        
+        # 2. Re-ranking
+        if len(candidates) > 0:
+            results = self._rerank(query, candidates, top_k)
+        else:
+            results = []
+        
+        end_time = time.time()
+        print(f"🔄 Re-ranking 완료: {len(candidates)}개 → {len(results)}개 ({end_time-start_time:.3f}초)")
+        
+        return results
+
+    def search_with_mode(self, query, top_k=None, mode="hybrid_rerank", alpha=0.5):
+        """검색 모드 선택"""
+        if mode == "embedding":
+            return self.search(query, top_k)
+        elif mode == "bm25":
+            return self.hybrid_search(query, top_k, alpha=0.0)
+        elif mode == "hybrid":
+            return self.hybrid_search(query, top_k, alpha=alpha)
+        elif mode == "hybrid_rerank":
+            return self.hybrid_search_with_rerank(query, top_k, alpha)
+        else:
+            raise ValueError(f"Unknown mode: {mode}")
+
+    @traceable(
+        name="RAG_Retriever_Search",
+        metadata={"component": "retriever", "version": "1.0"}
+    )
+    def search(self, query: str, top_k: int = None, filter_metadata: dict = None):
+        """
+        유사 문서 검색 (임베딩 기반)
+        """
+        start_time = time.time()
+        if top_k is None:
+            top_k = self.config.DEFAULT_TOP_K
+
+        if filter_metadata:
+            results = self.vectorstore.similarity_search_with_score(
+                query, k=top_k, filter=filter_metadata
+            )
+        else:
+            results = self.vectorstore.similarity_search_with_score(
+                query, k=top_k
+            )
+
+        formatted_results = []
+        for doc, score in results:
+            formatted_results.append({
+                'content': doc.page_content,
+                'metadata': doc.metadata,
+                'distance': score,
+                'relevance_score': 1 - score,
+                'filename': doc.metadata.get('파일명', 'N/A'),
+                'organization': doc.metadata.get('발주 기관', 'N/A')
+            })
+
+        end_time = time.time()
+        print(f"🔍 검색 완료: {len(results)}개 ({end_time-start_time:.3f}초)")
+        return formatted_results
+
+    def search_with_rerank(self, query, top_k=None, rerank_candidates=None):
+        """
+        임베딩 검색 + Re-ranking
+        
+        Args:
+            query: 검색 쿼리
+            top_k: 최종 반환할 문서 수
+            rerank_candidates: Re-rank할 후보 수
+        
+        Returns:
+            재정렬된 문서 리스트
+        """
+        start_time = time.time()
+        
+        if top_k is None:
+            top_k = self.config.DEFAULT_TOP_K
+        
+        if rerank_candidates is None:
+            rerank_candidates = top_k * 3
+        
+        # 1. 임베딩 검색으로 후보 가져오기
+        candidates = self.search(query, top_k=rerank_candidates)
+        
+        # 2. Re-ranking
+        if len(candidates) > 0:
+            results = self._rerank(query, candidates, top_k)
+        else:
+            results = []
+        
+        end_time = time.time()
+        print(f"🔄 Embedding + Re-ranking 완료: {len(candidates)}개 → {len(results)}개 ({end_time-start_time:.3f}초)")
+        
+        return results
+
+    def search_by_organization(self, query: str, organization: str, top_k: int = None):
+        """특정 발주기관만 검색"""
+        return self.search(
+            query, top_k=top_k, filter_metadata={'발주 기관': organization}
+        )
+
+    def get_retriever(self):
+        """LangChain 체인용 Retriever 반환"""
+        return self.vectorstore.as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": self.config.DEFAULT_TOP_K}
+        )

src/router/query_router.py

@@ -0,0 +1,65 @@
+# src/router/query_router.py
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+class QueryRouter:
+    """Query를 RAG vs Direct로 라우팅"""
+    
+    def __init__(self):
+        # 키워드 정의
+        self.greeting_keywords = [
+            "안녕", "hi", "hello", "반가워", "처음"
+        ]
+        
+        self.thanks_keywords = [
+            "고마워", "감사", "thanks", "고맙"
+        ]
+        
+        self.document_keywords = [
+            # 돈 관련
+            "예산", "비용", "금액", "원", "만원", "억",
+            # 일정 관련
+            "기한", "마감", "언제", "기간", "납기",
+            # 문서 관련
+            "요구사항", "제출", "서류", "양식", "평가",
+            # 조직 관련
+            "발주", "기관", "담당자", "연락처",
+            # 사업 관련
+            "사업명", "과업", "범위", "목적"
+        ]
+    
+    def classify(self, query: str) -> dict:
+        query_lower = query.lower()
+        
+        # 짧은 질문일 때만 인사/감사 체크
+        if len(query) < 20:  # ← is_short 대신 직접 체크
+            if any(kw in query_lower for kw in self.thanks_keywords):
+                return {
+                    'type': 'thanks',
+                    'confidence': 0.9,
+                    'reason': '감사 인사 감지'
+                }
+
+            elif any(kw in query_lower for kw in self.greeting_keywords):
+                return {
+                    'type': 'greeting',
+                    'confidence': 0.9,
+                    'reason': '인사 감지'
+                }
+
+        # 문서 관련 판별
+        if any(kw in query_lower for kw in self.document_keywords):
+            return {
+                'type': 'document',
+                'confidence': 0.85,
+                'reason': '문서 키워드 감지'
+            }
+        
+        # 3. 기본값
+        return {
+            'type': 'out_of_scope',
+            'confidence': 0.5,
+            'reason': 'RFP 키워드 없음'
+        }

src/router/query_router_lee.py

@@ -0,0 +1,77 @@
+# src/router/query_router.py
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+class QueryRouter:
+    """Query를 RAG vs Direct로 라우팅"""
+
+    def __init__(self):
+        # 키워드 정의
+        self.greeting_keywords = [
+            "안녕", "hi", "hello", "반가워", "처음", "인사"
+        ]
+
+        self.thanks_keywords = [
+            "고마워", "감사", "thanks", "고맙", "땡큐"
+        ]
+
+        self.document_keywords = [
+            # 돈 관련
+            "예산", "비용", "금액", "원", "만원", "억", "억원",
+            # 일정 관련
+            "기한", "마감", "언제", "기간", "납기", "일정",
+            # 문서 관련
+            "요구사항", "제출", "서류", "양식", "평가", "rfp",
+            # 조직 관련
+            "발주", "기관", "담당자", "연락처", "부처", "지자체",
+            # 사업/계약 관련
+            "사업", "사업명", "과업", "범위", "목적", "계약", "입찰",
+            "공고", "프로젝트", "위탁", "용역", "협상", "제안"
+        ]
+
+    def classify(self, query: str) -> dict:
+        query_lower = query.lower()
+        query_length = len(query)
+
+        # 짧은 질문일 때만 인사/감사 체크
+        if query_length < 25:
+            if any(kw in query_lower for kw in self.thanks_keywords):
+                return {
+                    'type': 'thanks',
+                    'confidence': 0.9,
+                    'reason': '감사 인사 감지'
+                }
+
+            if any(kw in query_lower for kw in self.greeting_keywords):
+                return {
+                    'type': 'greeting',
+                    'confidence': 0.9,
+                    'reason': '인사 감지'
+                }
+
+        # 문서 관련 판별 (키워드 또는 숫자+사업 맥락)
+        if any(kw in query_lower for kw in self.document_keywords):
+            match_count = sum(1 for kw in self.document_keywords if kw in query_lower)
+            confidence = min(0.7 + 0.05 * match_count, 0.95)
+            return {
+                'type': 'document',
+                'confidence': confidence,
+                'reason': f'문서 키워드 {match_count}개 감지'
+            }
+
+        # 숫자와 행정 용어가 혼합된 경우 약한 문서 추정
+        if any(ch.isdigit() for ch in query) and any(term in query_lower for term in ["사업", "과업", "계획"]):
+            return {
+                'type': 'document',
+                'confidence': 0.65,
+                'reason': '숫자와 사업 키워드 동시 감지'
+            }
+
+        # 기본값
+        return {
+            'type': 'out_of_scope',
+            'confidence': 0.4,
+            'reason': 'RFP 관련 키워드 미감지'
+        }

src/utils/config.py

@@ -0,0 +1,177 @@
+import os
+from dotenv import load_dotenv
+
+
+class Config:
+    """RAG 시스템 통합 설정 클래스"""
+
+    def __init__(self):
+        # .env 파일 로드
+        load_dotenv()
+        
+        # ===== API 키 =====
+        self.OPENAI_API_KEY = self._get_api_key()
+        
+        # ===== 경로 설정 =====
+        # 전처리
+        self.META_CSV_PATH = "./data/data_list.csv"
+        self.BASE_FOLDER_PATH = "./data/files/"
+        self.OUTPUT_CHUNKS_PATH = "./data/rag_chunks_final.csv"
+        
+        # RAG
+        self.RAG_INPUT_PATH = "./data/rag_chunks_final.csv"
+        self.DB_DIRECTORY = "./chroma_db"
+        
+        # ===== 전처리 설정 =====
+        self.CHUNK_SIZE = 1000
+        self.CHUNK_OVERLAP = 200
+        self.SEPARATORS = ["\n\n", "\n", " ", ""]
+        self.MIN_TEXT_LENGTH = 100  # 최소 텍스트 길이
+        
+        # ===== 임베딩 설정 =====
+        self.EMBEDDING_MODEL_NAME = "text-embedding-3-small"
+        self.BATCH_SIZE = 50
+        self.MAX_TOKENS_PER_BATCH = 250000
+        
+        # 청크 검증 기준
+        self.MIN_CHUNK_LENGTH = 10
+        self.MAX_CHUNK_LENGTH = 10000
+        
+        # ===== 벡터 DB 설정 =====
+        self.COLLECTION_NAME = "rag_documents"
+        
+        # ===== 검색 설정 =====
+        self.DEFAULT_TOP_K = 10
+        self.DEFAULT_ALPHA = 0.5  # Hybrid Search 가중치
+        self.DEFAULT_SEARCH_MODE = "hybrid_rerank"
+        
+        # ===== LLM 설정 =====
+        self.LLM_MODEL_NAME = "gpt-5-mini"
+        self.DEFAULT_TEMPERATURE = 0.0
+        self.DEFAULT_MAX_TOKENS = 1000
+
+        # ========== GGUF 모델 설정 (신규) ==========
+        self.GGUF_MODEL_PATH = "./models/Llama-3-Open-Ko-8B.Q4_K_M.gguf"
+        self.GGUF_N_GPU_LAYERS = 35  # GPU에 올릴 레이어 수 (0 = CPU만, 35 = 전체)
+        self.GGUF_N_CTX = 16384  # 컨텍스트 길이
+        self.GGUF_N_THREADS = 8  # CPU 스레드 수
+        
+        self.GGUF_MAX_NEW_TOKENS = 512
+        self.GGUF_TEMPERATURE = 0.5
+        self.GGUF_TOP_P = 0.9
+
+        # ========== Model Hub 설정 (신규) ==========
+        # Hugging Face Spaces 배포 시 True로 설정
+        self.USE_MODEL_HUB = os.getenv("USE_MODEL_HUB", "false").lower() == "true"
+        
+        # Model Hub 레포 정보
+        self.MODEL_HUB_REPO = "Dongjin1203/RFP_Documents_chatbot"  # 실제 레포명으로 변경 필요
+        self.MODEL_HUB_FILENAME = "Llama-3-Open-Ko-8B.Q4_K_M.gguf"
+        
+        # 다운로드 캐시 디렉토리
+        self.MODEL_CACHE_DIR = "./models"        
+        
+        # 시스템 프롬프트
+        self.SYSTEM_PROMPT = "당신은 RFP(제안요청서) 분석 및 요약 전문가입니다."
+
+    def validate_gguf(self):
+        """GGUF 모델 설정 유효성 검사"""
+        if not os.path.exists(self.GGUF_MODEL_PATH):
+            raise FileNotFoundError(
+                f"GGUF 모델 파일을 찾을 수 없습니다: {self.GGUF_MODEL_PATH}"
+            )
+        return True
+
+    def _get_api_key(self) -> str:
+        """환경변수에서 API 키 로드"""
+        api_key = os.getenv("OPENAI_API_KEY")
+        
+        if not api_key:
+            raise ValueError(
+                "OPENAI_API_KEY가 설정되지 않았습니다.\n"
+                "프로젝트 루트에 .env 파일을 만들고 OPENAI_API_KEY=your-key 를 추가하세요."
+            )
+        
+        return api_key
+
+    def validate_preprocess(self):
+        """전처리 설정 유효성 검사"""
+        if not os.path.exists(self.META_CSV_PATH):
+            raise FileNotFoundError(
+                f"메타 CSV 파일을 찾을 수 없습니다: {self.META_CSV_PATH}"
+            )
+        
+        if not os.path.exists(self.BASE_FOLDER_PATH):
+            raise FileNotFoundError(
+                f"파일 폴더를 찾을 수 없습니다: {self.BASE_FOLDER_PATH}"
+            )
+        
+        # 출력 폴더 생성
+        output_dir = os.path.dirname(self.OUTPUT_CHUNKS_PATH)
+        if output_dir:
+            os.makedirs(output_dir, exist_ok=True)
+        
+        return True
+
+    def validate_rag(self):
+        """RAG 설정 유효성 검사"""
+        if not self.OPENAI_API_KEY:
+            raise ValueError("OPENAI_API_KEY가 설정되지 않았습니다")
+        
+        if not os.path.exists(self.RAG_INPUT_PATH):
+            raise FileNotFoundError(
+                f"입력 파일을 찾을 수 없습니다: {self.RAG_INPUT_PATH}"
+            )
+        
+        return True
+
+    def validate_all(self):
+        """전체 설정 유효성 검사"""
+        self.validate_preprocess()
+        self.validate_rag()
+        return True
+
+    def validate(self):
+        """설정 유효성 검사 (하위 호환성)"""
+        return self.validate_preprocess()
+
+    def __repr__(self):
+        """설정 정보 출력"""
+        return f"""
+Config 설정:
+  [경로]
+  - 메타 CSV: {self.META_CSV_PATH}
+  - 파일 폴더: {self.BASE_FOLDER_PATH}
+  - 청크 출력: {self.OUTPUT_CHUNKS_PATH}
+  - DB 경로: {self.DB_DIRECTORY}
+  - 어댑터 경로: {self.FINETUNED_ADAPTER_PATH}
+  
+  [전처리]
+  - 청크 크기: {self.CHUNK_SIZE}
+  - 청크 오버랩: {self.CHUNK_OVERLAP}
+  
+  [모델]
+  - 임베딩: {self.EMBEDDING_MODEL_NAME}
+  - LLM: {self.LLM_MODEL_NAME}
+  - Fine-tuned: {self.FINETUNED_BASE_MODEL}
+  
+  [검색]
+  - Top-K: {self.DEFAULT_TOP_K}
+  - Alpha: {self.DEFAULT_ALPHA}
+  - 모드: {self.DEFAULT_SEARCH_MODE}
+  
+  [생성]
+  - Temperature: {self.FINETUNED_TEMPERATURE}
+  - Max Tokens: {self.FINETUNED_MAX_NEW_TOKENS}
+"""
+
+
+# 하위 호환성을 위한 별칭
+PreprocessConfig = Config
+RAGConfig = Config
+
+
+# 테스트용
+if __name__ == "__main__":
+    config = Config()
+    print(config)

src/utils/conversation_manager.py

@@ -0,0 +1,233 @@
+# src/utils/conversation_manager.py
+
+"""
+대화 히스토리 관리자 (메모리 기반)
+
+기능:
+- UI 표시용 / 분석용 히스토리 분리
+- 전체 대화 저장 (greeting, thanks, document, out_of_scope)
+- JSON 내보내기
+- 통계 기능
+"""
+
+from datetime import datetime
+from typing import List, Dict, Optional
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ConversationManager:
+    """
+    대화 히스토리 관리 (메모리 기반)
+    
+    Streamlit session_state와 함께 사용:
+    - UI 히스토리: Streamlit 메시지 형식
+    - DB 히스토리: 분석/저장용 형식
+    """
+    
+    def __init__(self):
+        """초기화"""
+        self.ui_history: List[Dict] = []   # Streamlit 표시용
+        self.db_history: List[Dict] = []   # 분석/저장용
+        
+        logger.info("💬 ConversationManager 초기화 완료")
+    
+    def add_message(
+        self,
+        user_msg: str,
+        ai_msg: str,
+        query_type: str,
+        sources: Optional[List] = None,
+        usage: Optional[Dict] = None,
+        search_mode: Optional[str] = None,
+        used_retrieval: bool = False,
+        routing_info: Optional[Dict] = None
+    ):
+        """
+        메시지 추가 (전체 저장)
+        
+        Args:
+            user_msg: 사용자 질문
+            ai_msg: AI 답변
+            query_type: 질문 유형 (greeting/thanks/document/out_of_scope)
+            sources: 참고 문서 리스트
+            usage: 토큰 사용량
+            search_mode: 검색 모드
+            used_retrieval: 검색 사용 여부
+            routing_info: 라우팅 정보
+        """
+        timestamp = datetime.now()
+        
+        # ===== UI 히스토리 (Streamlit 메시지 형식) =====
+        # 사용자 메시지
+        self.ui_history.append({
+            'role': 'user',
+            'content': user_msg,
+            'timestamp': timestamp
+        })
+        
+        # AI 메시지
+        self.ui_history.append({
+            'role': 'assistant',
+            'content': ai_msg,
+            'sources': sources or [],
+            'usage': usage or {},
+            'search_mode': search_mode,
+            'used_retrieval': used_retrieval,
+            'routing_info': routing_info,
+            'type': query_type,  # 분석용 추가
+            'timestamp': timestamp
+        })
+        
+        # ===== DB 히스토리 (분석용) =====
+        self.db_history.append({
+            'user': user_msg,
+            'assistant': ai_msg,
+            'type': query_type,
+            'timestamp': timestamp.isoformat(),
+            'sources_count': len(sources) if sources else 0,
+            'used_retrieval': used_retrieval,
+            'search_mode': search_mode,
+            'routing_info': routing_info
+        })
+        
+        logger.info(f"💾 대화 저장: {query_type} - {user_msg[:30]}...")
+    
+    def get_ui_history(self) -> List[Dict]:
+        """
+        UI 표시용 히스토리 반환 (Streamlit 형식)
+        
+        Returns:
+            Streamlit 메시지 리스트
+        """
+        return self.ui_history
+    
+    def get_db_history(self, last_n: Optional[int] = None) -> List[Dict]:
+        """
+        분석/저장용 히스토리 반환
+        
+        Args:
+            last_n: 최근 N개만 반환 (None이면 전체)
+        
+        Returns:
+            대화 기록 리스트
+        """
+        if last_n:
+            return self.db_history[-last_n:]
+        return self.db_history
+    
+    def get_history_by_type(self, query_type: str) -> List[Dict]:
+        """
+        특정 질문 유형만 필터링
+        
+        Args:
+            query_type: 'greeting', 'thanks', 'document', 'out_of_scope'
+        
+        Returns:
+            필터링된 대화 리스트
+        """
+        return [
+            msg for msg in self.db_history 
+            if msg['type'] == query_type
+        ]
+    
+    def get_statistics(self) -> Dict[str, int]:
+        """
+        질문 유형별 통계
+        
+        Returns:
+            {'greeting': 5, 'document': 20, ...}
+        """
+        from collections import Counter
+        
+        types = [msg['type'] for msg in self.db_history]
+        stats = dict(Counter(types))
+        
+        # 총 대화 수 추가
+        stats['total'] = len(self.db_history)
+        
+        return stats
+    
+    def export_to_json(self) -> str:
+        """
+        JSON 형식으로 내보내기
+        
+        Returns:
+            JSON 문자열
+        """
+        export_data = {
+            'timestamp': datetime.now().isoformat(),
+            'total_conversations': len(self.db_history),
+            'statistics': self.get_statistics(),
+            'conversations': self.db_history
+        }
+        
+        return json.dumps(export_data, ensure_ascii=False, indent=2)
+    
+    def clear(self):
+        """히스토리 초기화"""
+        self.ui_history = []
+        self.db_history = []
+        logger.info("🗑️ 대화 히스토리 초기화")
+    
+    def __len__(self):
+        """대화 개수 (사용자 질문 기준)"""
+        return len(self.db_history)
+    
+    def __repr__(self):
+        stats = self.get_statistics()
+        return (
+            f"ConversationManager("
+            f"total={stats.get('total', 0)}, "
+            f"document={stats.get('document', 0)}, "
+            f"greeting={stats.get('greeting', 0)}, "
+            f"thanks={stats.get('thanks', 0)}, "
+            f"out_of_scope={stats.get('out_of_scope', 0)})"
+        )
+
+
+# ===== 테스트 코드 =====
+if __name__ == "__main__":
+    # 테스트
+    manager = ConversationManager()
+    
+    # 대화 추가
+    manager.add_message(
+        user_msg="안녕하세요",
+        ai_msg="안녕하세요! 무엇을 도와드릴까요?",
+        query_type="greeting"
+    )
+    
+    manager.add_message(
+        user_msg="예산이 얼마인가요?",
+        ai_msg="예산은 5억원입니다.",
+        query_type="document",
+        sources=[{'content': '예산: 5억원', 'score': 0.95}],
+        used_retrieval=True,
+        search_mode="hybrid_rerank"
+    )
+    
+    manager.add_message(
+        user_msg="고마워요",
+        ai_msg="천만에요! 언제든 질문하세요.",
+        query_type="thanks"
+    )
+    
+    # 통계 출력
+    print("\n===== 통계 =====")
+    print(manager.get_statistics())
+    
+    # 히스토리 출력
+    print("\n===== DB 히스토리 =====")
+    for msg in manager.get_db_history():
+        print(f"{msg['type']}: {msg['user'][:20]}...")
+    
+    # JSON 내보내기
+    print("\n===== JSON Export =====")
+    print(manager.export_to_json())
+    
+    # Representation
+    print("\n===== Manager Info =====")
+    print(manager)

src/visualization/chatbot_app.py

@@ -0,0 +1,545 @@
+"""
+공공기관 사업제안서 RAG 챗봇
+
+기능:
+- 모델 선택 (API/로컬)
+- Query Router (검색 vs 직접 답변)
+- RAG 기반 질의응답 (Hybrid Search + Re-ranker)
+- 조건부 참고 문서 표시
+- 대화 히스토리 관리
+- 검색 모드 선택
+"""
+
+import streamlit as st
+import sys
+from pathlib import Path
+from datetime import datetime
+import json
+
+# 프로젝트 루트 추가
+root_dir = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(root_dir))
+
+from src.utils.config import RAGConfig
+from src.utils.conversation_manager import ConversationManager
+
+
+# ===== 페이지 설정 =====
+st.set_page_config(
+    page_title="공공기관 사업제안서 챗봇",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+
+# ===== 스타일 =====
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        color: #1f77b4;
+        margin-bottom: 0.5rem;
+    }
+    .sub-header {
+        font-size: 1.2rem;
+        color: #666;
+        margin-bottom: 2rem;
+    }
+    .chat-message {
+        padding: 1.5rem;
+        border-radius: 0.5rem;
+        margin-bottom: 1rem;
+        display: flex;
+        flex-direction: column;
+    }
+    .user-message {
+        background-color: #e3f2fd;
+        border-left: 5px solid #2196f3;
+    }
+    .assistant-message {
+        background-color: #f5f5f5;
+        border-left: 5px solid #4caf50;
+    }
+    .message-header {
+        font-weight: bold;
+        margin-bottom: 0.5rem;
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+    }
+    .message-content {
+        line-height: 1.6;
+    }
+    .source-document {
+        background-color: #fff9c4;
+        padding: 1rem;
+        border-radius: 0.3rem;
+        margin: 0.5rem 0;
+        border-left: 3px solid #fbc02d;
+    }
+    .source-header {
+        font-weight: bold;
+        color: #f57f17;
+        margin-bottom: 0.5rem;
+    }
+    .metadata {
+        font-size: 0.85rem;
+        color: #666;
+        margin-top: 0.5rem;
+    }
+    .token-usage {
+        background-color: #e8f5e9;
+        padding: 0.5rem 1rem;
+        border-radius: 0.3rem;
+        font-size: 0.9rem;
+        margin-top: 0.5rem;
+    }
+    .search-mode-info {
+        background-color: #e3f2fd;
+        padding: 0.5rem 1rem;
+        border-radius: 0.3rem;
+        font-size: 0.9rem;
+        margin-top: 0.5rem;
+    }
+    .routing-info {
+        background-color: #fff3e0;
+        padding: 0.5rem 1rem;
+        border-radius: 0.3rem;
+        font-size: 0.9rem;
+        margin-top: 0.5rem;
+        border-left: 3px solid #ff9800;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+# ===== 세션 상태 초기화 =====
+if 'conv_manager' not in st.session_state:
+    st.session_state.conv_manager = ConversationManager()
+
+if 'rag_pipeline' not in st.session_state:
+    st.session_state.rag_pipeline = None
+
+if 'model_type' not in st.session_state:
+    st.session_state.model_type = None
+
+if 'show_routing_info' not in st.session_state:
+    st.session_state.show_routing_info = False
+
+
+# ===== RAG 파이프라인 초기화 =====
+@st.cache_resource
+def initialize_rag(model_type):
+    """RAG 파이프라인 초기화 (모델 타입에 따라 분기)"""
+    try:
+        config = RAGConfig()
+        
+        if model_type == "API 모델 (GPT)":
+            from src.generator.generator import RAGPipeline
+            rag = RAGPipeline(config=config)
+            return rag, None, "API"
+        
+        else:  # "로컬 모델 (GGUF)"
+            from src.generator.generator_gguf import GGUFRAGPipeline
+            rag = GGUFRAGPipeline(config=config)
+            return rag, None, "Local-GGUF"
+            
+    except Exception as e:
+        return None, str(e), None
+
+
+# ===== 답변 생성 =====
+def generate_answer(query: str, top_k: int = 10, search_mode: str = "hybrid_rerank", alpha: float = 0.5):
+    """질의에 대한 답변 생성"""
+    try:
+        result = st.session_state.rag_pipeline.generate_answer(
+            query=query,
+            top_k=top_k,
+            search_mode=search_mode,
+            alpha=alpha
+        )
+        return result
+        
+    except Exception as e:
+        return {
+            'answer': f"❌ 오류가 발생했습니다: {str(e)}",
+            'sources': [],
+            'used_retrieval': False,  # ← 추가
+            'search_mode': search_mode,
+            'routing_info': None,  # ← 추가
+            'usage': {'total_tokens': 0, 'prompt_tokens': 0, 'completion_tokens': 0}
+        }
+
+
+# ===== 메시지 표시 =====
+def display_message(
+    role: str, 
+    content: str, 
+    sources: list = None, 
+    usage: dict = None, 
+    search_mode: str = None,
+    used_retrieval: bool = None,  # ← 신규
+    routing_info: dict = None  # ← 신규
+):
+    """
+    메시지를 화면에 표시
+    
+    Args:
+        role: 'user' 또는 'assistant'
+        content: 메시지 내용
+        sources: 참고 문서 리스트 (assistant만)
+        usage: 토큰 사용량 (assistant만)
+        search_mode: 검색 모드 (assistant만)
+        used_retrieval: 검색 사용 여부 (assistant만)
+        routing_info: 라우팅 정보 (assistant만)
+    """
+    if role == 'user':
+        st.markdown(f"""
+        <div class="chat-message user-message">
+            <div class="message-header">
+                👤 사용자
+            </div>
+            <div class="message-content">
+                {content}
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+    else:  # assistant
+        # 답변
+        st.markdown(f"""
+        <div class="chat-message assistant-message">
+            <div class="message-header">
+                🤖 챗봇
+            </div>
+            <div class="message-content">
+                {content}
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        # ===== 라우팅 정보 (개발 모드) =====
+        if st.session_state.show_routing_info and routing_info:
+            route_icon = "🔍" if routing_info.get('route') == 'rag' else "💬"
+            st.markdown(f"""
+            <div class="routing-info">
+                {route_icon} 라우팅: {routing_info.get('route', 'N/A').upper()} 
+                (신뢰도: {routing_info.get('confidence', 0):.2f}) - 
+                {routing_info.get('reason', 'N/A')}
+            </div>
+            """, unsafe_allow_html=True)
+        
+        # ===== 검색 모드 정보 (검색 사용 시만) =====
+        if used_retrieval and search_mode:
+            mode_display = {
+                'hybrid_rerank': '🔄 Hybrid + Re-ranker',
+                'hybrid': '🔀 Hybrid Search',
+                'embedding_rerank': '📊 임베딩 + Re-ranker',
+                'embedding': '📊 임베딩 검색',
+                'direct': '💬 Direct (검색 없음)'  # ← 추가
+            }
+            st.markdown(f"""
+            <div class="search-mode-info">
+                검색 모드: {mode_display.get(search_mode, search_mode)}
+            </div>
+            """, unsafe_allow_html=True)
+        
+        # ===== 참고 문서 (검색 사용 시만) =====
+        if used_retrieval and sources and len(sources) > 0:
+            st.markdown("### 📚 참고 문서")
+            
+            for i, source in enumerate(sources, 1):
+                metadata = source.get('metadata', {})
+                
+                # 관련도 점수
+                score = source.get('score', 0)
+                score_type = source.get('score_type', '')
+                
+                # 문서 내용 미리보기
+                content_preview = source.get('content', '')[:200] + "..."
+                
+                st.markdown(f"""
+                <div class="source-document">
+                    <div class="source-header">
+                        📄 문서 {i} (점수: {score:.3f} / {score_type})
+                    </div>
+                    <div>
+                        {content_preview}
+                    </div>
+                    <div class="metadata">
+                        📁 파일: {metadata.get('파일명', 'N/A')}<br>
+                        🏢 발주기관: {metadata.get('발주 기관', 'N/A')}<br>
+                        📋 사업명: {metadata.get('사업명', 'N/A')}
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+        elif not used_retrieval:
+            # 검색을 사용하지 않은 경우 안내
+            st.info("💬 이 답변은 문서 검색 없이 생성되었습니다.")
+        
+        # ===== 토큰 사용량 =====
+        if usage:
+            st.markdown(f"""
+            <div class="token-usage">
+                🔢 토큰 사용량: {usage.get('total_tokens', 0)} 
+                (프롬프트: {usage.get('prompt_tokens', 0)}, 
+                 완성: {usage.get('completion_tokens', 0)})
+            </div>
+            """, unsafe_allow_html=True)
+
+
+# ===== 메인 앱 =====
+def main():
+    # 헤더
+    st.markdown('<div class="main-header">🤖 공공기관 사업제안서 챗봇</div>', unsafe_allow_html=True)
+    st.markdown('<div class="sub-header">Query Router + RAG 기반 질의응답 시스템</div>', unsafe_allow_html=True)
+    
+    # ===== 사이드바 =====
+    with st.sidebar:
+        st.header("⚙️ 설정")
+        
+        # 모델 설정
+        st.markdown("### 🤖 모델 설정")
+        
+        model_type = st.selectbox(
+            "생성 모델 선택",
+            options=[
+                "API 모델 (GPT)",
+                "로컬 모델 (GGUF)"  
+            ],
+            index=1,  # 기본값을 GGUF로 (Router 있음)
+            help="""
+            • API 모델: OpenAI API 사용 (빠르고 안정적)
+            • 로컬 모델 (GGUF): Query Router 포함, 메모리 효율적
+            """
+        )
+        
+        # 모델 정보 표시
+        if model_type == "API 모델 (GPT)":
+            st.info("🌐 OpenAI GPT 모델 사용 중")
+        else:  # GGUF
+            st.success("⚡ 로컬 GGUF + Query Router 사용 중")
+        
+        st.markdown("---")
+        
+        # 검색 설정
+        st.markdown("### 🔍 검색 설정")
+        
+        search_mode = st.selectbox(
+            "검색 모드",
+            options=["hybrid", "embedding"],
+            index=0,
+            format_func=lambda x: {
+                "hybrid": "🔀 Hybrid Search (BM25 + 임베딩)",
+                "embedding": "📊 임베딩 검색"
+            }[x],
+            help="Hybrid: 키워드 + 의미 검색 병행 (권장)"
+        )
+        
+        # Reranker 토글
+        use_reranker = st.toggle(
+            "🔄 Re-ranker 사용",
+            value=True,
+            help="검색 결과를 CrossEncoder로 재정렬하여 정확도 향상 (권장)"
+        )
+        
+        # 실제 검색 모드 결정
+        if use_reranker:
+            if search_mode == "hybrid":
+                actual_search_mode = "hybrid_rerank"
+            else:  # embedding
+                actual_search_mode = "embedding_rerank"
+        else:
+            actual_search_mode = search_mode
+        
+        top_k = st.slider(
+            "검색할 문서 개수 (Top-K)",
+            min_value=1,
+            max_value=20,
+            value=7,  # 기본값 조정 (Router로 불필요한 검색 줄어듦)
+            help="Router가 검색이 필요한 경우에만 사용됨"
+        )
+        
+        alpha = st.slider(
+            "임베딩 가중치 (alpha)",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.5,
+            step=0.1,
+            help="0: BM25만, 1: 임베딩만, 0.5: 동일 가중치 (Hybrid 모드에서만 사용)",
+            disabled=(search_mode == "embedding")
+        )
+        
+        st.markdown("---")
+        
+        # 개발자 옵션
+        st.markdown("### 🛠️ 개발자 옵션")
+        
+        show_routing = st.toggle(
+            "🔍 라우팅 정보 표시",
+            value=False,
+            help="Router의 판단 과정을 표시 (디버깅용)"
+        )
+        st.session_state.show_routing_info = show_routing
+        
+        st.markdown("---")
+        
+        # 대화 관리
+        st.markdown("### 💬 대화 관리")
+        
+        if st.button("🗑️ 대화 초기화", use_container_width=True):
+            st.session_state.conv_manager.clear()
+            st.rerun()
+        
+        if st.button("💾 대화 다운로드", use_container_width=True):
+            if len(st.session_state.conv_manager) > 0:  # ✅ conv_manager 사용
+                json_str = st.session_state.conv_manager.export_to_json()
+                
+                st.download_button(
+                    label="📥 JSON 다운로드",
+                    data=json_str,
+                    file_name=f"chat_history_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                    mime="application/json",
+                    use_container_width=True
+                )
+        
+        st.markdown("---")
+        
+        # 통계
+        st.markdown("### 📊 통계")
+        stats = st.session_state.conv_manager.get_statistics()
+
+        st.metric("총 대화 수", stats.get('total', 0))
+        
+        # 현재 설정 표시
+        st.markdown("---")
+        st.markdown("### 📋 현재 설정")
+        st.text(f"모델: {model_type}")
+        st.text(f"검색 모드: {search_mode}")
+        st.text(f"Re-ranker: {'✅ ON' if use_reranker else '❌ OFF'}")
+        st.text(f"실제 모드: {actual_search_mode}")
+        st.text(f"Top-K: {top_k}")
+        if search_mode == "hybrid":
+            st.text(f"Alpha: {alpha}")
+        st.text(f"Router Info: {'✅ ON' if show_routing else '❌ OFF'}")
+    
+    # ===== RAG 파이프라인 초기화 =====
+    # 모델 타입이 변경되었거나 파이프라인이 없으면 재초기화
+    if (st.session_state.rag_pipeline is None or 
+        st.session_state.model_type != model_type):
+        
+        with st.spinner(f"🔄 {model_type} 초기화 중..."):
+            rag, error, rag_type = initialize_rag(model_type)
+            
+            if error:
+                st.error(f"❌ RAG 파이프라인 초기화 실패: {error}")
+                st.info("""
+                ### 💡 해결 방법
+                
+                1. ChromaDB가 생성되었는지 확인:
+```bash
+python main.py --step embed
+```
+                
+                2. OpenAI API 키가 설정되었는지 확인 (API 모델 사용 시):
+```bash
+# .env 파일
+OPENAI_API_KEY=your-key-here
+```
+                
+                3. GGUF 모델 파일 확인 (로컬 모델 사용 시):
+```bash
+# config.py
+GGUF_MODEL_PATH = "./models/your-model.gguf"
+```
+                
+                4. 필요한 패키지 설치:
+```bash
+pip install rank-bm25 sentence-transformers llama-cpp-python
+```
+                """)
+                return
+            
+            st.session_state.rag_pipeline = rag
+            st.session_state.model_type = model_type
+            st.success(f"✅ {rag_type} 모델 준비 완료!")
+    
+    # ===== 대화 히스토리 표시 =====
+    st.markdown("---")
+    
+    if len(st.session_state.conv_manager) == 0:  # ✅ conv_manager 사용
+        st.info("""
+        ### 👋 환영합니다!
+        
+        공공기관 사업제안서에 대해 질문해보세요. 
+        
+        **Router가 자동으로 판단합니다:**
+        - 📚 문서 검색이 필요한 질문 → RAG 수행
+        - 💬 일반 대화/인사 → 직접 답변
+        
+        **예시 질문:**
+        - "안녕하세요" (검색 안 함)
+        - "데이터 표준화 요구사항은 무엇인가요?" (검색 수행)
+        - "보안 관련 요구사항을 설명해주세요" (검색 수행)
+        - "고마워요" (검색 안 함)
+        """)
+    
+    # 기존 메시지 표시
+    for msg in st.session_state.conv_manager.get_ui_history():
+        display_message(
+            role=msg['role'],
+            content=msg['content'],
+            sources=msg.get('sources'),
+            usage=msg.get('usage'),
+            search_mode=msg.get('search_mode'),
+            used_retrieval=msg.get('used_retrieval'),  # ← 신규
+            routing_info=msg.get('routing_info')  # ← 신규
+        )
+    
+    # ===== 질문 입력 =====
+    st.markdown("---")
+    
+    with st.form(key='question_form', clear_on_submit=True):
+        user_input = st.text_area(
+            "질문을 입력하세요:",
+            height=100,
+            placeholder="예: 데이터 표준화 요구사항은 무엇인가요?"
+        )
+        
+        col1, col2, col3 = st.columns([1, 1, 4])
+        
+        with col1:
+            submit_button = st.form_submit_button("📤 전송", use_container_width=True)
+    
+    # ===== 질문 처리 =====
+    if submit_button and user_input:
+
+        # 답변 생성
+        with st.spinner("🤔 답변 생성 중..."):
+            result = generate_answer(
+                query=user_input,
+                top_k=top_k,
+                search_mode=actual_search_mode,
+                alpha=alpha
+            )
+        
+        # 어시스턴트 메시지 추가
+        st.session_state.conv_manager.add_message(
+            user_msg=user_input,
+            ai_msg=result['answer'],
+            query_type=result.get('query_type', 'unknown'),
+            sources=result.get('sources', []),
+            usage=result.get('usage', {}),
+            search_mode=result.get('search_mode'),
+            used_retrieval=result.get('used_retrieval', False),
+            routing_info=result.get('routing_info')
+        )
+        
+        # 화면 새로고침
+        st.rerun()
+
+
+if __name__ == "__main__":
+    main()

src/visualization/dimensionality_reduction.py

@@ -0,0 +1,246 @@
+"""
+차원 축소 (Dimensionality Reduction)
+1536차원 임베딩 벡터 → 2D/3D 좌표로 변환
+"""
+
+import numpy as np
+import pandas as pd
+from typing import Literal, Tuple
+from sklearn.decomposition import PCA
+from sklearn.manifold import TSNE
+import warnings
+warnings.filterwarnings('ignore')
+
+
+class DimensionalityReducer:
+    """차원 축소 클래스"""
+    
+    def __init__(
+        self,
+        method: Literal['pca', 'tsne'] = 'pca',
+        n_components: int = 2,
+        random_state: int = 42
+    ):
+        """
+        초기화
+        
+        Args:
+            method: 차원 축소 방법 ('pca' 또는 'tsne')
+            n_components: 축소할 차원 (2 또는 3)
+            random_state: 랜덤 시드
+        """
+        self.method = method
+        self.n_components = n_components
+        self.random_state = random_state
+        self.reducer = None
+        
+        self._initialize_reducer()
+    
+    def _initialize_reducer(self):
+        """차원 축소 모델 초기화"""
+        if self.method == 'pca':
+            self.reducer = PCA(
+                n_components=self.n_components,
+                random_state=self.random_state
+            )
+            print(f"✅ PCA 초기화 완료 ({self.n_components}D)")
+            
+        elif self.method == 'tsne':
+            self.reducer = TSNE(
+                n_components=self.n_components,
+                random_state=self.random_state,
+                perplexity=30,  # 기본값
+                max_iter=1000,  # n_iter → max_iter로 변경
+                verbose=0  # verbose=1 → 0 (Streamlit에서는 0이 좋음)
+            )
+            print(f"✅ t-SNE 초기화 완료 ({self.n_components}D)")
+            
+        else:
+            raise ValueError(f"지원하지 않는 방법: {self.method}")
+
+    def fit_transform(self, embeddings: np.ndarray) -> np.ndarray:
+        """
+        차원 축소 실행
+        
+        Args:
+            embeddings: 원본 임베딩 벡터 (N, 1536)
+            
+        Returns:
+            축소된 좌표 (N, 2) 또는 (N, 3)
+        """
+        print(f"\n차원 축소 시작...")
+        print(f"  방법: {self.method.upper()}")
+        print(f"  입력 shape: {embeddings.shape}")
+        print(f"  목표 차원: {self.n_components}D")
+        
+        # t-SNE의 경우 perplexity 재설정
+        if self.method == 'tsne':
+            n_samples = embeddings.shape[0]
+            perplexity = min(30, n_samples - 1)
+            self.reducer = TSNE(
+                n_components=self.n_components,
+                random_state=self.random_state,
+                perplexity=perplexity,
+                max_iter=1000  # n_iter → max_iter로 변경
+            )
+        
+        # 차원 축소
+        reduced = self.reducer.fit_transform(embeddings)
+        
+        print(f"  출력 shape: {reduced.shape}")
+        print(f"✅ 차원 축소 완료")
+        
+        # PCA인 경우 설명된 분산 비율 출력
+        if self.method == 'pca':
+            explained_var = self.reducer.explained_variance_ratio_
+            print(f"  설명된 분산:")
+            for i, var in enumerate(explained_var, 1):
+                print(f"    PC{i}: {var:.2%}")
+            print(f"    총합: {explained_var.sum():.2%}")
+        
+        return reduced
+    
+    def add_coordinates_to_dataframe(
+        self,
+        df: pd.DataFrame,
+        embeddings: np.ndarray
+    ) -> pd.DataFrame:
+        """
+        DataFrame에 2D/3D 좌표 추가
+        
+        Args:
+            df: 원본 DataFrame
+            embeddings: 임베딩 벡터
+            
+        Returns:
+            좌표가 추가된 DataFrame
+        """
+        # 차원 축소
+        reduced = self.fit_transform(embeddings)
+        
+        # DataFrame에 추가
+        df = df.copy()
+        
+        if self.n_components == 2:
+            df['x'] = reduced[:, 0]
+            df['y'] = reduced[:, 1]
+            print(f"\n✅ 2D 좌표 추가 완료 (x, y)")
+            
+        elif self.n_components == 3:
+            df['x'] = reduced[:, 0]
+            df['y'] = reduced[:, 1]
+            df['z'] = reduced[:, 2]
+            print(f"\n✅ 3D 좌표 추가 완료 (x, y, z)")
+        
+        return df
+
+
+def compare_methods(
+    embeddings: np.ndarray,
+    methods: list = ['pca', 'tsne'],
+    n_components: int = 2
+) -> dict:
+    """
+    여러 차원 축소 방법 비교
+    
+    Args:
+        embeddings: 임베딩 벡터
+        methods: 비교할 방법 리스트
+        n_components: 차원
+        
+    Returns:
+        {method: reduced_coords} 딕셔너리
+    """
+    results = {}
+    
+    for method in methods:
+        print(f"\n{'='*60}")
+        print(f"{method.upper()} 실행 중...")
+        print('='*60)
+        
+        reducer = DimensionalityReducer(
+            method=method,
+            n_components=n_components
+        )
+        
+        reduced = reducer.fit_transform(embeddings)
+        results[method] = reduced
+    
+    return results
+
+
+# ===== 단독 실행용 =====
+if __name__ == "__main__":
+    import argparse
+    from src.visualization.vector_db_loader import VectorDBLoader
+    from src.utils.rag_config import RAGConfig
+    
+    parser = argparse.ArgumentParser(description='차원 축소 테스트')
+    parser.add_argument(
+        '--method',
+        type=str,
+        choices=['pca', 'tsne', 'both'],
+        default='pca',
+        help='차원 축소 방법'
+    )
+    parser.add_argument(
+        '--n-components',
+        type=int,
+        choices=[2, 3],
+        default=2,
+        help='축소할 차원 (2D 또는 3D)'
+    )
+    parser.add_argument(
+        '--export',
+        type=str,
+        help='결과를 CSV로 저장할 경로 (선택)'
+    )
+    
+    args = parser.parse_args()
+    
+    # 1. 데이터 로드
+    print("="*60)
+    print("ChromaDB 데이터 로드")
+    print("="*60)
+    
+    config = RAGConfig()
+    loader = VectorDBLoader(config)
+    df = loader.to_dataframe()
+    
+    print(f"\n로드된 데이터: {len(df)}개")
+    
+    # 2. 임베딩 추출
+    embeddings = np.array(df['embedding'].tolist())
+    print(f"임베딩 shape: {embeddings.shape}")
+    
+    # 3. 차원 축소
+    if args.method == 'both':
+        results = compare_methods(embeddings, methods=['pca', 'tsne'], n_components=args.n_components)
+        
+        # PCA 결과를 DataFrame에 추가
+        reducer = DimensionalityReducer(method='pca', n_components=args.n_components)
+        df = reducer.add_coordinates_to_dataframe(df, embeddings)
+        
+    else:
+        reducer = DimensionalityReducer(method=args.method, n_components=args.n_components)
+        df = reducer.add_coordinates_to_dataframe(df, embeddings)
+    
+    # 4. 결과 확인
+    print("\n" + "="*60)
+    print("결과 요약")
+    print("="*60)
+    print(f"최종 DataFrame shape: {df.shape}")
+    print(f"좌표 컬럼: {['x', 'y', 'z'][:args.n_components]}")
+    
+    # 좌표 통계
+    print(f"\n좌표 범위:")
+    print(f"  x: [{df['x'].min():.2f}, {df['x'].max():.2f}]")
+    print(f"  y: [{df['y'].min():.2f}, {df['y'].max():.2f}]")
+    if args.n_components == 3:
+        print(f"  z: [{df['z'].min():.2f}, {df['z'].max():.2f}]")
+    
+    # 5. CSV 저장 (옵션)
+    if args.export:
+        df_export = df.drop(columns=['embedding'])
+        df_export.to_csv(args.export, index=False, encoding='utf-8-sig')
+        print(f"\n✅ 데이터 저장 완료: {args.export}")

src/visualization/streamlit_app.py

@@ -0,0 +1,404 @@
+"""
+벡터DB 시각화 Streamlit 앱
+ChromaDB 데이터를 2D/3D로 시각화
+"""
+import io
+import os
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import sys
+from pathlib import Path
+
+# 프로젝트 루트를 Python 경로에 추가
+root_dir = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(root_dir))
+
+from src.visualization.vector_db_loader import VectorDBLoader
+from src.visualization.dimensionality_reduction import DimensionalityReducer
+from src.utils.config import RAGConfig
+
+# ===== 자동 초기화 함수 =====
+@st.cache_resource
+def initialize_data():
+    """ChromaDB가 없으면 자동으로 전처리 + 임베딩 실행"""
+    
+    config = RAGConfig()
+    
+    # ChromaDB가 이미 존재하는지 확인
+    if os.path.exists(config.DB_DIRECTORY):
+        try:
+            # ChromaDB 연결 테스트
+            loader = VectorDBLoader(config)
+            info = loader.get_collection_info()
+            if info['total_documents'] > 0:
+                st.success(f"✅ 기존 ChromaDB 로드 완료 ({info['total_documents']}개 문서)")
+                return True
+        except:
+            st.warning("⚠️ 기존 ChromaDB가 손상되었습니다. 재생성합니다.")
+    
+    # ChromaDB가 없으면 생성
+    st.info("🔄 ChromaDB를 생성합니다. 최초 1회만 실행되며 약 2-3분 소요됩니다...")
+    
+    try:
+        # 전처리 실행
+        with st.spinner("1/2 전처리 실행 중..."):
+            from src.loader.preprocess_pipeline import RAGPreprocessPipeline
+            from src.utils.preprocess_config import PreprocessConfig
+            
+            preprocess_config = PreprocessConfig()
+            pipeline = RAGPreprocessPipeline(preprocess_config)
+            df_chunks = pipeline.run()
+            st.success(f"✅ 전처리 완료: {len(df_chunks)}개 청크")
+        
+        # 임베딩 실행
+        with st.spinner("2/2 임베딩 실행 중..."):
+            from src.embedding.rag_data_processing import RAGVectorDBPipeline
+            
+            rag_pipeline = RAGVectorDBPipeline(config)
+            rag_pipeline.build()
+            st.success("✅ ChromaDB 생성 완료!")
+        
+        return True
+        
+    except Exception as e:
+        st.error(f"❌ 초기화 실패: {e}")
+        st.info("""
+        ### 💡 수동 실행이 필요합니다
+        
+        로컬 환경에서:
+```bash
+        python main.py --step all
+```
+        """)
+        return False
+
+# ===== 페이지 설정 =====
+st.set_page_config(
+    page_title="벡터DB 시각화",
+    page_icon="🔍",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+
+# ===== 스타일 =====
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
+    .sub-header {
+        font-size: 1.2rem;
+        color: #666;
+        margin-bottom: 2rem;
+    }
+    .metric-container {
+        background-color: #f0f2f6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin-bottom: 1rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+# ===== 캐싱 함수 =====
+@st.cache_data
+def load_data():
+    """ChromaDB 데이터 로드 (캐싱)"""
+    config = RAGConfig()
+    loader = VectorDBLoader(config)
+    df = loader.to_dataframe()
+    
+    # 추출 실패 문서 필터링
+    df = df[~df['document'].str.contains('\[추출 실패', na=False)]
+    df = df[~df['document'].str.contains('\[PDF 추출 실패', na=False)]
+    df = df[~df['document'].str.contains('\[HWP 추출 실패', na=False)]
+    
+    # 인덱스 리셋
+    df = df.reset_index(drop=True)
+    
+    print(f"✅ 유효한 문서: {len(df)}개")
+    
+    # 임베딩 벡터 추출
+    embeddings = np.array(df['embedding'].tolist())
+    
+    return df, embeddings
+
+
+@st.cache_data
+def reduce_dimensions(embeddings, method, n_components):
+    """차원 축소 (캐싱)"""
+    reducer = DimensionalityReducer(
+        method=method,
+        n_components=n_components
+    )
+    reduced = reducer.fit_transform(embeddings)
+    return reduced
+
+
+# ===== 메인 앱 =====
+def main():
+    st.set_page_config(
+        page_title="벡터DB 시각화",
+        page_icon="🔍",
+        layout="wide"
+    )
+    # 헤더
+    st.markdown('<div class="main-header">🔍 벡터DB 시각화</div>', unsafe_allow_html=True)
+    st.markdown('<div class="sub-header">ChromaDB 임베딩 공간 탐색</div>', unsafe_allow_html=True)
+    
+    # 자동 초기화
+    if not initialize_data():
+        return
+
+    # 데이터 로드
+    with st.spinner("데이터 로드 중..."):
+        try:
+            df, embeddings = load_data()
+        except Exception as e:
+            st.error(f"❌ 데이터 로드 실패: {e}")
+            st.info("먼저 임베딩 단계를 실행하세요: `python main.py --step embed`")
+            return
+    
+    # 데이터가 없으면 종료
+    if len(df) == 0:
+        st.warning("⚠️ ChromaDB에 데이터가 없습니다!")
+        st.info("먼저 임베딩 단계를 실행하세요: `python main.py --step embed`")
+        return
+    
+    # ===== 사이드바 =====
+    with st.sidebar:
+        st.header("⚙️ 설정")
+        
+        # 통계 정보
+        st.markdown("### 📊 데이터 정보")
+        st.metric("총 문서 수", len(df))
+        st.metric("임베딩 차원", embeddings.shape[1])
+        
+        st.markdown("---")
+        
+        # 차원 축소 설정
+        st.markdown("### 🎯 차원 축소")
+        
+        method = st.selectbox(
+            "방법",
+            options=['pca', 'tsne'],
+            format_func=lambda x: {
+                'pca': 'PCA (빠름)',
+                'tsne': 't-SNE (느림, 더 정확)'
+            }[x]
+        )
+        
+        n_components = st.radio(
+            "차원",
+            options=[2, 3],
+            format_func=lambda x: f"{x}D"
+        )
+        
+        st.markdown("---")
+        
+        # 필터링 옵션
+        st.markdown("### 🎨 시각화 옵션")
+        
+        # 색상 기준
+        color_options = ['없음'] + [col for col in df.columns 
+                                    if col not in ['id', 'document', 'embedding', 'x', 'y', 'z']]
+        
+        color_by = st.selectbox(
+            "색상 기준",
+            options=color_options
+        )
+        
+        # 크기 옵션
+        point_size = st.slider(
+            "포인트 크기",
+            min_value=3,
+            max_value=15,
+            value=8
+        )
+        
+        # 투명도
+        opacity = st.slider(
+            "투명도",
+            min_value=0.1,
+            max_value=1.0,
+            value=0.7,
+            step=0.1
+        )
+        
+        st.markdown("---")
+        
+        # 필터링
+        st.markdown("### 🔍 필터")
+        
+        filter_col = st.selectbox(
+            "필터링 기준",
+            options=['없음'] + color_options[1:]  # '없음' 제외한 나머지
+        )
+        
+        filter_values = []
+        if filter_col != '없음':
+            unique_values = df[filter_col].unique()
+            filter_values = st.multiselect(
+                f"{filter_col} 선택",
+                options=unique_values,
+                default=list(unique_values)[:5] if len(unique_values) > 5 else list(unique_values)
+            )
+    
+    # ===== 차원 축소 =====
+    with st.spinner(f"{method.upper()}로 차원 축소 중..."):
+        reduced = reduce_dimensions(embeddings, method, n_components)
+    
+    # DataFrame에 좌표 추가
+    df_viz = df.copy()
+    df_viz['x'] = reduced[:, 0]
+    df_viz['y'] = reduced[:, 1]
+    if n_components == 3:
+        df_viz['z'] = reduced[:, 2]
+    
+    # 필터링 적용
+    if filter_col != '없음' and filter_values:
+        df_viz = df_viz[df_viz[filter_col].isin(filter_values)]
+        st.info(f"필터링 결과: {len(df_viz)}개 문서")
+    
+    # ===== 시각화 =====
+    st.markdown("---")
+    st.markdown("### 📈 임베딩 공간 시각화")
+    
+    # hover 데이터 준비
+    hover_data = {
+        'document': True,
+        'x': ':.2f',
+        'y': ':.2f'
+    }
+    
+    if n_components == 3:
+        hover_data['z'] = ':.2f'
+    
+    # 메타데이터 hover에 추가
+    for col in ['파일명', '발주 기관', '사업명']:
+        if col in df_viz.columns:
+            hover_data[col] = True
+    
+    # 색상 설정
+    color = None if color_by == '없음' else color_by
+    
+    # 2D 시각화
+    if n_components == 2:
+        fig = px.scatter(
+            df_viz,
+            x='x',
+            y='y',
+            color=color,
+            hover_data=hover_data,
+            title=f"벡터 임베딩 공간 ({method.upper()}, 2D)",
+            labels={'x': 'PC1' if method == 'pca' else 'Dim 1',
+                   'y': 'PC2' if method == 'pca' else 'Dim 2'},
+            height=700,
+            opacity=opacity
+        )
+        
+        fig.update_traces(marker=dict(size=point_size))
+        
+    # 3D 시각화
+    else:
+        fig = px.scatter_3d(
+            df_viz,
+            x='x',
+            y='y',
+            z='z',
+            color=color,
+            hover_data=hover_data,
+            title=f"벡터 임베딩 공간 ({method.upper()}, 3D)",
+            labels={'x': 'PC1' if method == 'pca' else 'Dim 1',
+                   'y': 'PC2' if method == 'pca' else 'Dim 2',
+                   'z': 'PC3' if method == 'pca' else 'Dim 3'},
+            height=700,
+            opacity=opacity
+        )
+        
+        fig.update_traces(marker=dict(size=point_size))
+    
+    # 레이아웃 업데이트
+    fig.update_layout(
+        showlegend=True,
+        hovermode='closest',
+        plot_bgcolor='white'
+    )
+    
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # ===== 통계 정보 =====
+    st.markdown("---")
+    st.markdown("### 📊 통계 정보")
+    
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("표시된 문서", len(df_viz))
+    
+    with col2:
+        st.metric("필터링된 문서", len(df) - len(df_viz))
+    
+    with col3:
+        if method == 'pca':
+            # PCA 설명된 분산 표시
+            reducer = DimensionalityReducer(method='pca', n_components=n_components)
+            reducer.fit_transform(embeddings)
+            explained_var = reducer.reducer.explained_variance_ratio_.sum()
+            st.metric("설명된 분산", f"{explained_var:.1%}")
+        else:
+            st.metric("차원 축소 방법", "t-SNE")
+    
+    with col4:
+        st.metric("임베딩 차원", embeddings.shape[1])
+    
+    # ===== 데이터 테이블 =====
+    if st.checkbox("📋 데이터 테이블 보기", value=False):
+        st.markdown("---")
+        st.markdown("### 📋 데이터 테이블")
+        
+        # 표시할 컬럼 선택
+        display_cols = st.multiselect(
+            "표시할 컬럼 선택",
+            options=[col for col in df_viz.columns if col != 'embedding'],
+            default=['파일명', '발주 기관', '사업명'][:min(3, len(df_viz.columns))]
+        )
+        
+        if display_cols:
+            st.dataframe(
+                df_viz[display_cols],
+                use_container_width=True,
+                height=400
+            )
+    
+    # ===== 다운로드 옵션 =====
+    st.markdown("---")
+    st.markdown("### 💾 데이터 다운로드")
+
+    df_download = df_viz.drop(columns=['embedding'])
+
+    # BytesIO 버퍼 생성
+    buffer = io.BytesIO()
+
+    # Excel 파일 생성
+    with pd.ExcelWriter(buffer, engine='openpyxl') as writer:
+        df_download.to_excel(writer, index=False, sheet_name='VectorDB')
+
+    st.download_button(
+        label="📥 Excel 다운로드",
+        data=buffer.getvalue(),
+        file_name="vectordb_visualization.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        use_container_width=True
+    )
+
+    st.caption("💡 Excel에서 바로 열 수 있으며 한글이 정상 표시됩니다.")
+
+if __name__ == "__main__":
+    main()

src/visualization/vector_db_loader.py

@@ -0,0 +1,296 @@
+"""
+ChromaDB 벡터 데이터베이스 로더
+임베딩 벡터와 메타데이터를 추출하여 시각화용 데이터 준비
+"""
+
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Optional
+from langchain_chroma import Chroma
+from langchain_openai.embeddings import OpenAIEmbeddings
+
+from src.utils.config import RAGConfig
+
+
+class VectorDBLoader:
+    """ChromaDB에서 벡터와 메타데이터를 추출하는 클래스"""
+    
+    def __init__(self, config: RAGConfig = None):
+        """
+        초기화
+        
+        Args:
+            config: RAG 설정 객체
+        """
+        self.config = config or RAGConfig()
+        self.vectorstore = None
+        self.embeddings = None
+        
+        self._initialize()
+    
+    def _initialize(self):
+        """임베딩 모델 및 벡터스토어 초기화"""
+        # 임베딩 모델 초기화
+        self.embeddings = OpenAIEmbeddings(
+            model=self.config.EMBEDDING_MODEL_NAME,
+            openai_api_key=self.config.OPENAI_API_KEY
+        )
+        
+        # 벡터스토어 연결
+        self.vectorstore = Chroma(
+            embedding_function=self.embeddings,
+            persist_directory=self.config.DB_DIRECTORY,
+            collection_name=self.config.COLLECTION_NAME
+        )
+        
+        print(f"✅ ChromaDB 연결 완료")
+        print(f"   경로: {self.config.DB_DIRECTORY}")
+        print(f"   Collection: {self.config.COLLECTION_NAME}")
+    
+    def get_collection_info(self) -> Dict:
+        """
+        Collection 기본 정보 반환
+        
+        Returns:
+            dict: Collection 통계 정보
+        """
+        collection = self.vectorstore._collection
+        count = collection.count()
+        
+        if count == 0:
+            return {
+                'total_documents': 0,
+                'embedding_dimension': 0,
+                'metadata_keys': [],
+                'collection_name': self.config.COLLECTION_NAME
+            }
+        
+        # 샘플 데이터 가져오기
+        sample = collection.get(limit=1, include=['embeddings', 'metadatas'])
+        
+        # 임베딩 차원 확인
+        embedding_dim = 0
+        if sample.get('embeddings') is not None and len(sample['embeddings']) > 0:
+            embedding_dim = len(sample['embeddings'][0])
+        
+        # 메타데이터 키 확인
+        metadata_keys = []
+        if sample.get('metadatas') is not None and len(sample['metadatas']) > 0:
+            if sample['metadatas'][0]:
+                metadata_keys = list(sample['metadatas'][0].keys())
+        
+        info = {
+            'total_documents': count,
+            'embedding_dimension': embedding_dim,
+            'metadata_keys': metadata_keys,
+            'collection_name': self.config.COLLECTION_NAME
+        }
+        
+        return info
+    
+    def extract_all_data(self) -> Dict:
+        """
+        모든 데이터를 추출
+        
+        Returns:
+            dict: {
+                'embeddings': 임베딩 벡터 배열 (numpy),
+                'metadatas': 메타데이터 리스트,
+                'documents': 문서 텍스트 리스트,
+                'ids': 문서 ID 리스트
+            }
+        """
+        print("\n데이터 추출 중...")
+        
+        collection = self.vectorstore._collection
+        
+        # 모든 데이터 가져오기
+        results = collection.get(
+            include=['embeddings', 'metadatas', 'documents']
+        )
+        
+        # 데이터가 없는 경우 처리
+        if not results['ids'] or len(results['ids']) == 0:
+            print("⚠️  ChromaDB에 데이터가 없습니다!")
+            print("   먼저 임베딩 단계를 실행하세요: python main.py --step embed")
+            return {
+                'embeddings': np.array([]),
+                'metadatas': [],
+                'documents': [],
+                'ids': []
+            }
+        
+        # numpy array로 변환
+        embeddings_array = np.array(results['embeddings'])
+        
+        print(f"✅ 총 {len(results['ids'])}개의 청크를 불러왔습니다.")
+        if embeddings_array.ndim == 2:  # 2D 배열인 경우에만
+            print(f"✅ 임베딩 차원: {embeddings_array.shape[1]}차원")
+        
+        return {
+            'embeddings': embeddings_array,
+            'metadatas': results['metadatas'],
+            'documents': results['documents'],
+            'ids': results['ids']
+        }
+    
+    def to_dataframe(self, data: Dict = None) -> pd.DataFrame:
+        """
+        추출한 데이터를 DataFrame으로 변환
+        
+        Args:
+            data: extract_all_data()의 결과 (None이면 자동 추출)
+            
+        Returns:
+            pd.DataFrame: 정리된 데이터프레임
+        """
+        if data is None:
+            data = self.extract_all_data()
+        
+        # 데이터가 없으면 빈 DataFrame 반환
+        if len(data['ids']) == 0:
+            return pd.DataFrame()
+        
+        # 기본 컬럼
+        df = pd.DataFrame({
+            'id': data['ids'],
+            'document': data['documents'],
+        })
+        
+        # 메타데이터를 개별 컬럼으로 분리
+        if data['metadatas']:
+            # 메타데이터의 모든 키 추출
+            metadata_keys = set()
+            for metadata in data['metadatas']:
+                if metadata:
+                    metadata_keys.update(metadata.keys())
+            
+            # 각 메타데이터 키를 컬럼으로 추가
+            for key in metadata_keys:
+                df[key] = [
+                    metadata.get(key, None) if metadata else None 
+                    for metadata in data['metadatas']
+                ]
+        
+        # 임베딩 벡터 추가 (numpy array로)
+        df['embedding'] = list(data['embeddings'])
+        
+        print(f"\n📊 DataFrame 정보:")
+        print(f"   - Shape: {df.shape}")
+        print(f"   - Columns: {df.columns.tolist()}")
+        
+        return df
+    
+    def get_metadata_stats(self, df: pd.DataFrame = None) -> Dict:
+        """
+        메타데이터 통계 정보
+        
+        Args:
+            df: DataFrame (None이면 자동 생성)
+            
+        Returns:
+            dict: 메타데이터별 통계
+        """
+        if df is None or len(df) == 0:
+            return {}
+        
+        stats = {}
+        
+        # embedding과 document 컬럼 제외
+        metadata_cols = [col for col in df.columns 
+                        if col not in ['id', 'document', 'embedding']]
+        
+        for col in metadata_cols:
+            if df[col].dtype == 'object':  # 범주형 데이터
+                stats[col] = {
+                    'type': 'categorical',
+                    'unique_count': df[col].nunique(),
+                    'top_values': df[col].value_counts().head(10).to_dict()
+                }
+            else:  # 숫자형 데이터
+                stats[col] = {
+                    'type': 'numerical',
+                    'mean': float(df[col].mean()),
+                    'std': float(df[col].std()),
+                    'min': float(df[col].min()),
+                    'max': float(df[col].max())
+                }
+        
+        return stats
+    
+    def print_summary(self):
+        """데이터 요약 정보 출력"""
+        print("\n" + "="*60)
+        print("ChromaDB 데이터 요약")
+        print("="*60)
+        
+        # Collection 정보
+        info = self.get_collection_info()
+        print(f"\n📦 Collection: {info['collection_name']}")
+        print(f"📊 총 문서 수: {info['total_documents']}")
+        
+        # 데이터가 없으면 여기서 종료
+        if info['total_documents'] == 0:
+            print("\n⚠️  ChromaDB에 데이터가 없습니다!")
+            print("   먼저 임베딩 단계를 실행하세요:")
+            print("   python main.py --step embed")
+            print("="*60)
+            return None
+        
+        print(f"🧮 임베딩 차원: {info['embedding_dimension']}")
+        print(f"🏷️  메타데이터 키: {', '.join(info['metadata_keys'])}")
+        
+        # DataFrame 생성
+        df = self.to_dataframe()
+        
+        if len(df) == 0:
+            print("\n⚠️  DataFrame 생성 실패")
+            print("="*60)
+            return None
+        
+        # 메타데이터 통계
+        stats = self.get_metadata_stats(df)
+        
+        if stats:
+            print("\n📈 메타데이터 분포:")
+            for key, stat in stats.items():
+                if stat['type'] == 'categorical':
+                    print(f"\n  [{key}]")
+                    print(f"    - 고유값: {stat['unique_count']}개")
+                    print(f"    - 상위 값:")
+                    for val, count in list(stat['top_values'].items())[:5]:
+                        print(f"      • {val}: {count}개")
+        
+        print("\n" + "="*60)
+        
+        return df
+
+
+# ===== 단독 실행용 =====
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='ChromaDB 데이터 추출 및 확인')
+    parser.add_argument(
+        '--export',
+        type=str,
+        help='DataFrame을 CSV로 저장할 경로 (선택사항)'
+    )
+    
+    args = parser.parse_args()
+    
+    # 설정 초기화
+    config = RAGConfig()
+    
+    # 데이터 로더 초기화
+    loader = VectorDBLoader(config)
+    
+    # 요약 정보 출력 및 DataFrame 생성
+    df = loader.print_summary()
+    
+    # CSV 저장 (옵션)
+    if df is not None and args.export:
+        # 임베딩 벡터를 제외하고 저장 (파일 크기 때문)
+        df_export = df.drop(columns=['embedding'])
+        df_export.to_csv(args.export, index=False, encoding='utf-8-sig')
+        print(f"\n✅ 데이터 저장 완료: {args.export}")