diff --git a/.gitignore b/.gitignore
index d6e2969..3f05da7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,10 @@
 rag_preprocessed_data.csv
 rag_preprocessed_data.json
 .env
-chroma_db/
\ No newline at end of file
+chroma_db/
+
+__pycache__/
+*.pyc
+.DS_Store
+*.egg-info/
+.venv/
diff --git a/README.md b/README.md
index c954bf3..42ab472 100644
--- a/README.md
+++ b/README.md
@@ -44,31 +44,24 @@ pip install -r requirements.txt
 
 ## 🚀 실행 순서 (Running Order)
 
-1.  **데이터 정제 (Data Cleaning):**
-    `creation_science_data.csv`를 정제하여 `cleaned_creation_science_data.csv`를 생성합니다.
+1.  **데이터 정제 + 전처리 (Data Pipeline):**
+    `creation_science_data.csv`를 정제하고, 청크로 나누어 `rag_preprocessed_data.json`을 생성합니다.
 
     ```bash
-    python data_cleaning.py
+    python data_pipeline.py
     ```
 
-2.  **데이터 전처리 (Data Preprocessing):**
-    정제된 CSV를 읽어 청크로 나누고 `rag_preprocessed_data.json`을 생성합니다.
-
-    ```bash
-    python data_preprocessing_for_RAG.py
-    ```
-
-3.  **벡터 DB 적재 (Vector DB Ingestion):**
+2.  **벡터 DB 적재 (Vector DB Ingestion):**
     생성된 JSON 데이터를 `chroma_db` 폴더에 임베딩하여 저장합니다. (Ollama에서 `qwen3-embedding:8b` 모델이 실행 중이어야 합니다.)
     ```bash
     python ingest_vector_db.py
     ```
 
-3.1 **Google Drive에서 chroma_db 파일 다운**
-1,2,3 뛰어 넘어도 됨.
+2.1 **Google Drive에서 chroma_db 파일 다운**
+1,2 뛰어 넘어도 됨.
 https://drive.google.com/file/d/1zdxkGgW2R2mLA_XRxAENbLTTPSnNydI2/view?usp=drive_link
 
-4.  **애플리케이션 실행 (Run App):**
+3.  **애플리케이션 실행 (Run App):**
     Streamlit 웹 인터페이스를 실행합니다.
     ```bash
     streamlit run app.py
@@ -76,9 +69,12 @@ https://drive.google.com/file/d/1zdxkGgW2R2mLA_XRxAENbLTTPSnNydI2/view?usp=drive
 
 ## 📂 파일 구조 (File Structure)
 
-- `app.py`: Streamlit 챗봇 UI, Hybrid Retriever 및 Reranker 로직
-- `data_cleaning.py`: 중복 제거 및 노이즈 텍스트 정제
-- `data_preprocessing_for_RAG.py`: RecursiveCharacterTextSplitter를 이용한 청킹
+- `config.py`: 모델명, 경로, 파라미터 등 설정값 중앙 관리
+- `app.py`: Streamlit 챗봇 UI
+- `text_utils.py`: 텍스트 클리닝 및 태그 분리 유틸리티
+- `retriever.py`: 문서 로딩, 벡터DB, 하이브리드 검색 및 Reranker 로직
+- `chain.py`: LLM 프롬프트 및 생성 체인
+- `data_pipeline.py`: 데이터 정제 + RAG 전처리/청킹 통합 파이프라인
 - `ingest_vector_db.py`: ChromaDB 생성 및 Ollama 기반 임베딩 적재
 - `creation_science_data.csv`: 원본 데이터셋
 - `chroma_db/`: 벡터 데이터베이스 저장 폴더
diff --git a/VERSIONS.md b/VERSIONS.md
index 3805f23..534c5e1 100644
--- a/VERSIONS.md
+++ b/VERSIONS.md
@@ -4,7 +4,38 @@
 
 ---
 
-## [v0.0.4] - 2026-04-13 (최신 버전)
+## [v0.0.5] - 2026-04-15 (최신 버전)
+
+### 🌟 주요 특징 (Features)
+
+- **코드 모듈 분리**: 단일 `app.py`(294줄)를 `config.py`, `text_utils.py`, `retriever.py`, `chain.py`, `app.py`(120줄)로 분리하여 유지보수성 및 테스트 용이성 향상.
+- **설정값 중앙 관리**: 모델명, 경로, 파라미터 등 하드코딩된 설정값을 `config.py`로 통합하여 한 곳에서 관리.
+- **중복 코드 제거**: `app.py`와 `ingest_vector_db.py`에 중복 존재하던 `load_documents()` 함수를 `retriever.py`로 통합.
+- **데이터 파이프라인 통합**: `data_cleaning.py`와 `data_preprocessing_for_RAG.py`를 `data_pipeline.py`로 통합하여 1,2단계를 한 번에 실행.
+- **Reranker 모델 자동 전환**: `config.py`에서 `RERANKER_MODEL`만 변경하면 BAAI/Qwen 모델에 맞는 kwargs가 자동 적용.
+- **의존성 버전 고정**: `requirements.txt`에 최소 버전 제약을 추가하여 환경 재현성 향상.
+- **`.gitignore` 보강**: `__pycache__/`, `.DS_Store`, `.venv/` 등 표준 Python 제외 항목 추가.
+
+### 🤖 모델 구성 (Models)
+
+- **LLM (Generation):** `qwen2.5:14b` (via Ollama)
+- **Embedding:** `qwen3-embedding:8b` (via Ollama)
+- **Reranker:** `BAAI/bge-reranker-v2-m3` (via HuggingFace CrossEncoder)
+  - Optimization: `torch.float16` 적용
+
+### 📂 변경된 파일 구조 (File Structure)
+
+- `config.py` (신규): 설정값 중앙 관리
+- `text_utils.py` (신규): 텍스트 클리닝 유틸리티
+- `retriever.py` (신규): 문서 로딩, 검색, Reranker
+- `chain.py` (신규): LLM 프롬프트 및 생성 체인
+- `data_pipeline.py` (신규): 데이터 정제 + 전처리 통합
+- `app.py` (리팩터링): UI 로직만 담당
+- `ingest_vector_db.py` (리팩터링): 공통 모듈 임포트로 전환
+
+---
+
+## [v0.0.4] - 2026-04-13 (이전 버전)
 
 ### 🌟 주요 특징 (Features)
 
diff --git a/app.py b/app.py
index ffd2f29..05c142a 100644
--- a/app.py
+++ b/app.py
@@ -1,199 +1,47 @@
 import streamlit as st
-import os, json, time, re
-from pathlib import Path
-import torch
-
-from langchain_core.documents import Document
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import RunnablePassthrough
-from langchain_core.output_parsers import StrOutputParser
-
-from langchain_chroma import Chroma
-from langchain_community.retrievers import BM25Retriever
-from langchain_classic.retrievers import EnsembleRetriever, ContextualCompressionRetriever
-from langchain_ollama import ChatOllama, OllamaEmbeddings
-
-from langchain_community.cross_encoders import HuggingFaceCrossEncoder
-from langchain_classic.retrievers.document_compressors import CrossEncoderReranker
-
-
-
-# ──────────────────────────────────────────────
-# [NEW] 텍스트 클리닝 및 태그 분리 함수
-# ──────────────────────────────────────────────
-def clean_response(text: str) -> str:
-    """불필요한 XML 태그를 제거하고 과도한 빈 줄을 정리합니다."""
-    FORBIDDEN_TAGS = [
-        "thought", "references", "conclusion", "answer",
-        "response", "output", "result", "context", "question",
-    ]
-    for tag in FORBIDDEN_TAGS:
-        text = re.sub(rf"</?{tag}>", "", text, flags=re.IGNORECASE)
-    text = re.sub(r"\n{3,}", "\n\n", text)
-    return text.strip()
-
-def extract_think_and_answer(text: str):
-    """문자열에서 <think> 부분과 실제 답변 부분을 완벽하게 분리합니다."""
-    if "<think>" in text and "</think>" in text:
-        # think 태그가 완전히 닫힌 경우
-        parts = text.split("</think>", 1)
-        think_content = parts[0].split("<think>")[-1].strip()
-        answer_content = clean_response(parts[1])
-        return think_content, answer_content
-    elif "<think>" in text:
-        # think 태그가 열려있고 아직 닫히지 않은 경우 (스트리밍 중)
-        think_content = text.split("<think>")[-1].strip()
-        return think_content, ""
-    else:
-        # think 태그가 아예 없는 경우
-        return "", clean_response(text)
-
-
-# 1) 데이터 로드
-@st.cache_data(show_spinner=False)
-def load_documents(path="rag_preprocessed_data.json"):
-    if not os.path.exists(path):
-        st.error(f"데이터 파일({path})이 없습니다.")
-        st.stop()
-    with open(path, "r", encoding="utf-8") as f:
-        raw = json.load(f)
-    docs = []
-    for item in raw:
-        content = f"제목: {item.get('title', '')}\n내용: {item.get('content_chunk', '')}"
-        metadata = {
-            "chunk_id": item.get("chunk_id", ""),
-            "title": item.get("title", ""),
-            "url": item.get("url", "")
-        }
-        docs.append(Document(page_content=content.strip(), metadata=metadata))
-    return docs
-
-
-# 2) VectorStore 로드
-@st.cache_resource(show_spinner=False)
-def load_vectorstore(persist_directory="./chroma_db"):
-    if not Path(persist_directory).exists():
-        st.error("벡터DB가 아직 생성되지 않았습니다. 데이터를 먼저 임베딩하세요.")
-        st.stop()
-    embed = OllamaEmbeddings(model="qwen3-embedding:8b")
-    return Chroma(persist_directory=persist_directory, embedding_function=embed)
-
-
-# 3) Hybrid + Cross-Encoder Reranker 초기화
-@st.cache_resource(show_spinner=False)
-def init_retrievers(_docs, _vector_db):
-    bm25 = BM25Retriever.from_documents(_docs)
-    bm25.k = 10
-    vect = _vector_db.as_retriever(search_kwargs={"k": 10})
-    hybrid = EnsembleRetriever(retrievers=[bm25, vect], weights=[0.5, 0.5])
-
-    # 💻 옵션 A: 16GB 메모리용
-    model_name = "BAAI/bge-reranker-v2-m3"
-    model_kwargs = {"model_kwargs": {"torch_dtype": torch.float16}}
-
-    # 🖥️ 옵션 B: 32GB 메모리용 (무거운 Qwen3 4B 모델, 16-bit 사용)
-    # model_name = "Qwen/Qwen3-Reranker-4B"
-    # model_kwargs = {
-    # "automodel_args": {
-    #     "torch_dtype": torch.float16, 
-    #     "trust_remote_code": True
-    #   }
-    # }
-
-    model = HuggingFaceCrossEncoder(model_name=model_name, model_kwargs=model_kwargs)
-    re_ranker = CrossEncoderReranker(model=model, top_n=5)
-    return ContextualCompressionRetriever(base_compressor=re_ranker, base_retriever=hybrid)
-
-# 4) 검색된 문서 텍스트화 및 고유 URL 하이퍼링크 추출
-def format_docs_and_extract_urls(docs):
-    context_parts = []
-    unique_refs = {}  # URL 중복 제거를 위한 딕셔너리
-    
-    for d in docs:
-        title = d.metadata.get('title', '제목 없음')
-        url = d.metadata.get('url', '')
-        
-        # LLM에게 제공할 본문 구성 (LLM은 이 텍스트만 보고 답변을 생성)
-        context_parts.append(f"[출처: {title}]\n{d.page_content}")
-        
-        # URL을 딕셔너리의 Key로 사용하여 중복을 자동으로 제거
-        # url 값이 존재하는 경우에만 추가
-        if url and url not in unique_refs:
-            unique_refs[url] = title
-            
-    context_str = "\n\n---\n\n".join(context_parts)
-    
-    # 🔗 마크다운 문법 [Title](URL)을 사용하여 제목에 하이퍼링크 씌우기
-    ref_list = [f"- [{title}]({url})" for url, title in unique_refs.items()]
-    refs_str = "\n".join(ref_list)
-    
-    return context_str, refs_str
-
-
-# 5) 생성(Generation) 체인
-@st.cache_resource(show_spinner=False)
-def init_generation_chain():
-    llm = ChatOllama(
-        model="qwen2.5:14b",
-        # model="gpt-oss:20b",
-        temperature=0.3,
-        top_p=0.9,
-        repeat_penalty=1.15,
-        stop=["<|im_end|>", "User:", "Question:"]
-    )
-
-    prompt = ChatPromptTemplate.from_template("""
-당신은 창조과학의 관점과 주장을 소개하는 전문 해설가입니다. 
-당신의 주된 목적은 제공된 자료(Context)를 바탕으로 창조과학계의 해석과 증거들을 사용자에게 상세히 전달하는 것입니다. 
-아래의 지침을 반드시 준수하여 답변하십시오.
+import time
 
-[최우선 지침: 출처 표기 금지]
-- 🚨 답변 맨 마지막에 참고 자료나 URL 링크를 직접 작성하지 마십시오. (시스템이 자동으로 정확한 고유 링크를 100% 첨부할 것입니다.) 당신은 오직 내용을 설명하는 데에만 집중하십시오.
+from text_utils import clean_response, extract_think_and_answer
+from retriever import (
+    load_documents, load_vectorstore, init_retrievers,
+    format_docs_and_extract_urls,
+)
+from chain import init_generation_chain
 
-[답변 가이드라인]
-1. 무한 반복 금지 및 간결한 구성: 동일한 주장이나 문장을 무의미하게 계속 반복(무한 루프)하지 마십시오. 각 주장은 한 번씩만 명확하고 상세하게 설명하며, Context에 제시된 내용을 모두 다루었다면 추가적인 반복 없이 자연스럽게 답변을 마무리하십시오.
-2. 태도 및 어조: 창조과학계의 주장과 해석을 '소개'하는 전문적인 어조를 유지하십시오.
-   - ✅ "창조과학에서는 ~라고 설명합니다", "창조과학자들은 이를 ~의 근거로 주장합니다"
-   - ❌ "이것은 사실입니다", "과학적으로 증명되었습니다" 등 단정적인 사실 선언은 지양하십시오.
-3. 내용의 집중: 오직 창조과학 내부의 논리와 제공된 자료의 증거(유물, 기록 등)를 상세히 설명하는 데 집중하십시오. 부정적인 의견이나 타 이론과의 비교는 지양하십시오.
-4. 상세 설명 및 구체성: 각 항목 설명 시 Context에 포함된 구체적인 지명, 유물 이름, 역사적 기록, 인명 등을 반드시 포함하여 최소 3문장 이상 상세하게 작성하십시오.
-5. 태그 사용 금지: <thought>, <references>, <think>, <answer> 등 어떠한 XML/HTML 태그도 포함하지 마십시오.
-                                              
-[출력 형식]
 
-(창조과학적 관점에서 해당 주제를 정중하게 소개하는 도입 문구)
-
-- **(주장/해석 1 제목)**: (상세 설명. 구체적 지명 및 증거 포함 3문장 이상)
-- **(주장/해석 2 제목)**: (상세 설명. 구체적 지명 및 증거 포함 3문장 이상)
+# ==========================================
+# —— Streamlit 앱 UI (챗봇 스타일) ——
+# ==========================================
+st.set_page_config(page_title="Chat DDS", page_icon="🌎")
+st.title("🌎 Chat DDS 🌎")
 
-Chat History:
-{chat_history}
 
-Context:
-{context}
+@st.cache_data(show_spinner=False)
+def get_documents():
+    return load_documents()
 
-Question:
-{question}
 
-Answer:
-""")
+@st.cache_resource(show_spinner=False)
+def get_vectorstore():
+    return load_vectorstore()
 
-    return prompt | llm | StrOutputParser()
 
+@st.cache_resource(show_spinner=False)
+def get_generation_chain():
+    return init_generation_chain()
 
-# ==========================================
-# —— Streamlit 앱 UI (챗봇 스타일) ——
-# ==========================================
-st.set_page_config(page_title="Chat DDS", page_icon="🌎")
-st.title("🌎 Chat DDS 🌎")
 
-docs = load_documents()
-vector_db = load_vectorstore()
+try:
+    docs = get_documents()
+    vector_db = get_vectorstore()
+except FileNotFoundError as e:
+    st.error(str(e))
+    st.stop()
 
 if "rerank_retriever" not in st.session_state:
     st.session_state.rerank_retriever = init_retrievers(docs, vector_db)
 
-generation_chain = init_generation_chain()
+generation_chain = get_generation_chain()
 
 if "messages" not in st.session_state:
     st.session_state.messages = []
@@ -203,17 +51,16 @@ def init_generation_chain():
     with st.chat_message(msg["role"]):
         if msg["role"] == "assistant":
             think_content, answer_content = extract_think_and_answer(msg["content"])
-            
+
             # 사고 과정 UI 렌더링 주석 처리
             # if think_content:
             #     with st.expander("🧠 AI의 사고 과정"):
             #         st.markdown(think_content)
-            
+
             if answer_content:
                 st.markdown(answer_content)
-            # 만약 think 분리 없이 전체가 답변으로 넘어온 경우 처리 (사고 과정 제거 후 대비)
             elif think_content and not answer_content:
-                 st.markdown(think_content)
+                st.markdown(think_content)
         else:
             st.markdown(clean_response(msg["content"]))
 
@@ -228,7 +75,6 @@ def init_generation_chain():
     chat_history_str = ""
     for m in st.session_state.messages[:-1]:
         role_name = "User" if m["role"] == "user" else "Assistant"
-        # 컨텍스트로 넘길 때는 AI의 사고 과정은 제외하고 답변만 넘김
         _, ans_content = extract_think_and_answer(m["content"])
         content = ans_content if m["role"] == "assistant" else clean_response(m["content"])
         chat_history_str += f"{role_name}: {content}\n"
@@ -241,11 +87,10 @@ def init_generation_chain():
 
             try:
                 retrieved_docs = st.session_state.rerank_retriever.invoke(query)
-            except Exception as e:
+            except Exception:
                 st.warning("⚠️ Reranking 중 오류가 발생하여 기본 검색 결과를 사용합니다.")
                 retrieved_docs = st.session_state.rerank_retriever.base_retriever.invoke(query)[:5]
 
-            # ✅ 여기서 고유 URL 리스트를 함께 반환받습니다.
             context_str, refs_str = format_docs_and_extract_urls(retrieved_docs)
 
             st.write(f"✅ {len(retrieved_docs)}개의 핵심 문서를 찾았습니다.")
@@ -266,7 +111,7 @@ def init_generation_chain():
         for chunk in response_stream:
             full_response += chunk
             current_think, current_answer = extract_think_and_answer(full_response)
-            
+
             if current_answer:
                 answer_placeholder.markdown(current_answer + " ▌")
             elif current_think and not current_answer:
@@ -274,14 +119,12 @@ def init_generation_chain():
 
         # ── 스트리밍 종료: 커서 제거 및 출처 강제 결합 ──
         final_think, final_answer = extract_think_and_answer(full_response)
-        
-        # 파이썬 로직으로 생성된 100% 확실한 출처 리스트(하이퍼링크)를 답변 끝에 병합
+
         if refs_str:
             final_answer_with_refs = final_answer + f"\n\n🔗 **참고 자료:**\n{refs_str}"
         else:
             final_answer_with_refs = final_answer
-            
-        # 화면에 렌더링
+
         if final_answer_with_refs:
             answer_placeholder.markdown(final_answer_with_refs)
         else:
@@ -290,5 +133,4 @@ def init_generation_chain():
         end_time = time.time()
         status.update(label=f"✅ 답변 생성 완료! ({end_time - start_time:.2f}초)", state="complete")
 
-        # 전체 답변 저장 (원본에 출처가 결합된 상태로 세션 기록 저장)
-        st.session_state.messages.append({"role": "assistant", "content": final_answer_with_refs})
\ No newline at end of file
+        st.session_state.messages.append({"role": "assistant", "content": final_answer_with_refs})
diff --git a/chain.py b/chain.py
new file mode 100644
index 0000000..5df90c0
--- /dev/null
+++ b/chain.py
@@ -0,0 +1,57 @@
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_ollama import ChatOllama
+
+from config import (
+    LLM_MODEL, LLM_TEMPERATURE, LLM_TOP_P,
+    LLM_REPEAT_PENALTY, LLM_STOP_TOKENS,
+)
+
+PROMPT_TEMPLATE = """
+당신은 창조과학의 관점과 주장을 소개하는 전문 해설가입니다.
+당신의 주된 목적은 제공된 자료(Context)를 바탕으로 창조과학계의 해석과 증거들을 사용자에게 상세히 전달하는 것입니다.
+아래의 지침을 반드시 준수하여 답변하십시오.
+
+[최우선 지침: 출처 표기 금지]
+- 🚨 답변 맨 마지막에 참고 자료나 URL 링크를 직접 작성하지 마십시오. (시스템이 자동으로 정확한 고유 링크를 100% 첨부할 것입니다.) 당신은 오직 내용을 설명하는 데에만 집중하십시오.
+
+[답변 가이드라인]
+1. 무한 반복 금지 및 간결한 구성: 동일한 주장이나 문장을 무의미하게 계속 반복(무한 루프)하지 마십시오. 각 주장은 한 번씩만 명확하고 상세하게 설명하며, Context에 제시된 내용을 모두 다루었다면 추가적인 반복 없이 자연스럽게 답변을 마무리하십시오.
+2. 태도 및 어조: 창조과학계의 주장과 해석을 '소개'하는 전문적인 어조를 유지하십시오.
+   - ✅ "창조과학에서는 ~라고 설명합니다", "창조과학자들은 이를 ~의 근거로 주장합니다"
+   - ❌ "이것은 사실입니다", "과학적으로 증명되었습니다" 등 단정적인 사실 선언은 지양하십시오.
+3. 내용의 집중: 오직 창조과학 내부의 논리와 제공된 자료의 증거(유물, 기록 등)를 상세히 설명하는 데 집중하십시오. 부정적인 의견이나 타 이론과의 비교는 지양하십시오.
+4. 상세 설명 및 구체성: 각 항목 설명 시 Context에 포함된 구체적인 지명, 유물 이름, 역사적 기록, 인명 등을 반드시 포함하여 최소 3문장 이상 상세하게 작성하십시오.
+5. 태그 사용 금지: <thought>, <references>, <think>, <answer> 등 어떠한 XML/HTML 태그도 포함하지 마십시오.
+
+[출력 형식]
+
+(창조과학적 관점에서 해당 주제를 정중하게 소개하는 도입 문구)
+
+- **(주장/해석 1 제목)**: (상세 설명. 구체적 지명 및 증거 포함 3문장 이상)
+- **(주장/해석 2 제목)**: (상세 설명. 구체적 지명 및 증거 포함 3문장 이상)
+
+Chat History:
+{chat_history}
+
+Context:
+{context}
+
+Question:
+{question}
+
+Answer:
+"""
+
+
+def init_generation_chain():
+    """LLM 생성 체인을 초기화합니다."""
+    llm = ChatOllama(
+        model=LLM_MODEL,
+        temperature=LLM_TEMPERATURE,
+        top_p=LLM_TOP_P,
+        repeat_penalty=LLM_REPEAT_PENALTY,
+        stop=LLM_STOP_TOKENS,
+    )
+    prompt = ChatPromptTemplate.from_template(PROMPT_TEMPLATE)
+    return prompt | llm | StrOutputParser()
diff --git a/config.py b/config.py
new file mode 100644
index 0000000..400256d
--- /dev/null
+++ b/config.py
@@ -0,0 +1,31 @@
+# ── Data Pipeline Paths ──
+RAW_CSV_PATH = "creation_science_data.csv"
+CLEANED_CSV_PATH = "cleaned_creation_science_data.csv"
+RAG_CSV_PATH = "rag_preprocessed_data.csv"
+RAG_JSON_PATH = "rag_preprocessed_data.json"
+
+# ── Vector DB ──
+CHROMA_DB_DIR = "./chroma_db"
+
+# ── Models ──
+EMBEDDING_MODEL = "qwen3-embedding:8b"
+LLM_MODEL = "qwen2.5:14b"
+
+# Reranker (16GB: "BAAI/bge-reranker-v2-m3", 32GB: "Qwen/Qwen3-Reranker-4B")
+RERANKER_MODEL = "BAAI/bge-reranker-v2-m3"
+RERANKER_TOP_N = 5
+
+# ── Retriever Parameters ──
+BM25_K = 10 # keyword search
+VECTOR_K = 10 # context(vector) search
+ENSEMBLE_WEIGHTS = [0.5, 0.5] # [BM25, Vector]
+
+# ── LLM Parameters ──
+LLM_TEMPERATURE = 0.3
+LLM_TOP_P = 0.9
+LLM_REPEAT_PENALTY = 1.15
+LLM_STOP_TOKENS = ["<|im_end|>", "User:", "Question:"]
+
+# ── Chunking Parameters ──
+CHUNK_SIZE = 1000
+CHUNK_OVERLAP = 200
diff --git a/data_cleaning.py b/data_cleaning.py
deleted file mode 100644
index 5e43316..0000000
--- a/data_cleaning.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import pandas as pd
-import re
-import os
-
-def run_cleaning_process():
-    input_file = 'creation_science_data.csv'
-    output_file = 'cleaned_creation_science_data.csv'
-
-    if not os.path.exists(input_file):
-        print(f"오류: {input_file} 파일이 현재 경로에 없습니다.")
-        return
-
-    print(f"[{input_file}] 데이터 정제를 시작합니다...")
-
-    df = pd.read_csv(input_file)
-    initial_count = len(df)
-
-    df = df.drop_duplicates(subset=['title', 'content'], keep='first')
-
-    def clean_content(text):
-        if not isinstance(text, str):
-            return ""
-        
-        # 수정 1: .* 를 제거하여 뒤에 오는 모든 텍스트가 삭제되는 것을 방지
-        noise_pattern = r"(알림 뒤로|알림 설정|더보기 게시물|마이페이지|로그아웃|찾아오시는길|자료실MAP|창조과학스쿨|E-Book|기도월력|문의게시판|후원기관|전체보기|추천사이트|로그인이 필요합니다)"
-        
-        # 수정 2: flags=re.DOTALL 제거 (해당 키워드만 삭제하도록 변경)
-        text = re.sub(noise_pattern, "", text)
-        
-        # 연속된 공백 및 줄바꿈 하나로 통일
-        text = re.sub(r'\s+', ' ', text).strip()
-        return text
-
-    df['content'] = df['content'].apply(clean_content)
-
-    # 임베딩에 부적합한 짧은 텍스트 제거 (100자 미만)
-    df = df[df['content'].str.len() > 100]
-
-    df.to_csv(output_file, index=False, encoding='utf-8-sig')
-
-    final_count = len(df)
-    deleted_count = initial_count - final_count
-
-    print("-" * 40)
-    print(f"정제 작업이 완료되었습니다!")
-    print(f"기존 행 개수: {initial_count:,}개")
-    print(f"정제 후 행 개수: {final_count:,}개")
-    print(f"삭제된 행 개수: {deleted_count:,}개 (약 {deleted_count/initial_count*100:.1f}% 감소)")
-    print(f"최종 파일 저장 경로: {os.path.abspath(output_file)}")
-    print("-" * 40)
-
-if __name__ == "__main__":
-    run_cleaning_process()
\ No newline at end of file
diff --git a/data_pipeline.py b/data_pipeline.py
new file mode 100644
index 0000000..da178bd
--- /dev/null
+++ b/data_pipeline.py
@@ -0,0 +1,116 @@
+"""
+데이터 파이프라인: 1단계(정제) + 2단계(RAG 전처리/청킹)를 통합 실행합니다.
+벡터DB 적재(3단계)는 시간이 오래 걸리므로 ingest_vector_db.py에서 별도 실행합니다.
+"""
+
+import os
+import re
+
+import pandas as pd
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+from config import (
+    RAW_CSV_PATH, CLEANED_CSV_PATH,
+    RAG_CSV_PATH, RAG_JSON_PATH,
+    CHUNK_SIZE, CHUNK_OVERLAP,
+)
+
+
+# ── 1단계: 원본 CSV 데이터 정제 ──
+
+def clean_data(input_file=RAW_CSV_PATH, output_file=CLEANED_CSV_PATH):
+    if not os.path.exists(input_file):
+        print(f"오류: {input_file} 파일이 현재 경로에 없습니다.")
+        return None
+
+    print(f"[{input_file}] 데이터 정제를 시작합니다...")
+
+    df = pd.read_csv(input_file)
+    initial_count = len(df)
+
+    df = df.drop_duplicates(subset=['title', 'content'], keep='first')
+
+    def _clean_content(text):
+        if not isinstance(text, str):
+            return ""
+        noise_pattern = (
+            r"(알림 뒤로|알림 설정|더보기 게시물|마이페이지|로그아웃|찾아오시는길"
+            r"|자료실MAP|창조과학스쿨|E-Book|기도월력|문의게시판|후원기관"
+            r"|전체보기|추천사이트|로그인이 필요합니다)"
+        )
+        text = re.sub(noise_pattern, "", text)
+        text = re.sub(r'\s+', ' ', text).strip()
+        return text
+
+    df['content'] = df['content'].apply(_clean_content)
+    df = df[df['content'].str.len() > 100]
+
+    df.to_csv(output_file, index=False, encoding='utf-8-sig')
+
+    final_count = len(df)
+    deleted_count = initial_count - final_count
+
+    print("-" * 40)
+    print(f"정제 작업이 완료되었습니다!")
+    print(f"기존 행 개수: {initial_count:,}개")
+    print(f"정제 후 행 개수: {final_count:,}개")
+    print(f"삭제된 행 개수: {deleted_count:,}개 (약 {deleted_count/initial_count*100:.1f}% 감소)")
+    print(f"최종 파일 저장 경로: {os.path.abspath(output_file)}")
+    print("-" * 40)
+
+    return df
+
+
+# ── 2단계: 정제된 CSV를 청킹하여 RAG용 데이터 생성 ──
+
+def preprocess_for_rag(input_file=CLEANED_CSV_PATH, output_csv=RAG_CSV_PATH, output_json=RAG_JSON_PATH):
+    df = pd.read_csv(input_file)
+
+    def _clean_text(text):
+        if not isinstance(text, str):
+            return ""
+        text = re.sub(r'\r\n', '\n', text)
+        text = re.sub(r'\n+', '\n', text)
+        text = re.sub(r'\s+', ' ', text)
+        return text.strip()
+
+    df['cleaned_content'] = df['content'].apply(_clean_text)
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=CHUNK_SIZE,
+        chunk_overlap=CHUNK_OVERLAP,
+        length_function=len,
+        separators=["\n\n", "\n", ".", "?", "!", " ", ""]
+    )
+
+    processed_data = []
+    for index, row in df.iterrows():
+        if not row['cleaned_content']:
+            continue
+        chunks = text_splitter.split_text(row['cleaned_content'])
+        for i, chunk in enumerate(chunks):
+            processed_data.append({
+                "chunk_id": f"doc_{index}_chunk_{i}",
+                "title": row['title'],
+                "url": row['url'],
+                "reference_urls": row['reference_urls'],
+                "content_chunk": chunk,
+            })
+
+    final_df = pd.DataFrame(processed_data)
+    final_df.to_csv(output_csv, index=False, encoding='utf-8-sig')
+    final_df.to_json(output_json, orient="records", force_ascii=False, indent=4)
+
+    print(f"전처리 완료! 원본 문서 {len(df)}개가 {len(final_df)}개의 청크로 분할되어 저장되었습니다.")
+
+
+# ── 통합 실행 ──
+
+def main():
+    result = clean_data()
+    if result is not None:
+        preprocess_for_rag()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_preprocessing_for_RAG.py b/data_preprocessing_for_RAG.py
deleted file mode 100644
index b616430..0000000
--- a/data_preprocessing_for_RAG.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import pandas as pd
-import re
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-
-# 1. 데이터 로드
-file_path = "cleaned_creation_science_data.csv"
-df = pd.read_csv(file_path)
-
-# 2. 텍스트 정제 함수 (Cleaning)
-def clean_text(text):
-    if not isinstance(text, str):
-        return ""
-    # 불필요한 이스케이프 문자나 과도한 공백, 개행문자 정제
-    text = re.sub(r'\r\n', '\n', text)
-    text = re.sub(r'\n+', '\n', text)
-    text = re.sub(r'\s+', ' ', text)
-    return text.strip()
-
-# content 컬럼 정제 적용
-df['cleaned_content'] = df['content'].apply(clean_text)
-
-# 3. 텍스트 청킹 (Chunking) 설정
-# RecursiveCharacterTextSplitter는 문단 -> 문장 -> 단어 순으로 문맥이 끊기지 않게 분할해줍니다.
-text_splitter = RecursiveCharacterTextSplitter(
-    chunk_size=1000,       # 하나의 청크 크기 (글자 수 기준. 임베딩 모델에 따라 500~1000 권장)
-    chunk_overlap=200,     # 청크 간 문맥이 끊기지 않도록 겹치게 할 글자 수
-    length_function=len,
-    separators=["\n\n", "\n", ".", "?", "!", " ", ""]
-)
-
-processed_data = []
-
-# 4. 데이터프레임 순회하며 청킹 및 메타데이터 결합
-for index, row in df.iterrows():
-    # 정제된 텍스트가 없는 경우 건너뜀
-    if not row['cleaned_content']:
-        continue
-        
-    # 텍스트 분할
-    chunks = text_splitter.split_text(row['cleaned_content'])
-    
-    for i, chunk in enumerate(chunks):
-        # 각 청크 단위로 새로운 딕셔너리 생성 (메타데이터 보존)
-        processed_data.append({
-            "chunk_id": f"doc_{index}_chunk_{i}", # 고유 ID 부여
-            "title": row['title'],
-            "url": row['url'],
-            "reference_urls": row['reference_urls'],
-            "content_chunk": chunk # 분할된 텍스트
-        })
-
-# 5. 최종 데이터프레임 생성
-final_df = pd.DataFrame(processed_data)
-
-# 6. 최종 형태 저장 (CSV 및 JSON)
-# 한글 깨짐 방지를 위해 utf-8-sig 인코딩 사용
-final_df.to_csv("rag_preprocessed_data.csv", index=False, encoding='utf-8-sig')
-
-# RAG 시스템에 따라 JSON 형태를 요구하는 경우가 많으므로 JSON으로도 저장
-final_df.to_json("rag_preprocessed_data.json", orient="records", force_ascii=False, indent=4)
-
-print(f"전처리 완료! 원본 문서 {len(df)}개가 {len(final_df)}개의 청크로 분할되어 저장되었습니다.")
\ No newline at end of file
diff --git a/ingest_vector_db.py b/ingest_vector_db.py
index e80dab2..0bdf258 100644
--- a/ingest_vector_db.py
+++ b/ingest_vector_db.py
@@ -1,37 +1,12 @@
 import argparse
-import json
 from pathlib import Path
 
-from langchain_core.documents import Document
 from langchain_chroma import Chroma
-
-# 로컬 임베딩을 위한 Ollama 라이브러리 임포트
 from langchain_ollama import OllamaEmbeddings
-
-# 진행 상황 표시를 위한 tqdm 임포트
 from tqdm import tqdm
 
-
-def load_documents(path: str) -> list[Document]:
-    """
-    미리 전처리된 창조과학 JSON 데이터를 읽어 LangChain Document 리스트로 변환합니다.
-    """
-    with open(path, "r", encoding="utf-8") as f:
-        raw = json.load(f)
-
-    docs = []
-    for item in raw:
-        # 이미 청크 분할이 되어 있으므로 content_chunk를 메인 텍스트로 사용
-        content = f"제목: {item.get('title', '')}\n내용: {item.get('content_chunk', '')}"
-        
-        # 메타데이터 구성 (출처 URL과 고유 ID 포함)
-        metadata = {
-            "chunk_id": item.get("chunk_id", ""),
-            "title": item.get("title", ""),
-            "url": item.get("url", "")
-        }
-        docs.append(Document(page_content=content.strip(), metadata=metadata))
-    return docs
+from config import EMBEDDING_MODEL, RAG_JSON_PATH, CHROMA_DB_DIR
+from retriever import load_documents
 
 
 def ingest(json_path: str, persist_directory: str, batch_size: int = 100) -> None:
@@ -47,22 +22,17 @@ def ingest(json_path: str, persist_directory: str, batch_size: int = 100) -> Non
     ids = [doc.metadata.get("chunk_id") or f"doc_{i}" for i, doc in enumerate(docs)]
 
     # 3. 로컬 임베딩 모델 설정
-    print("Ollama qwen3-embedding:8b 모델을 준비 중입니다...")
-    # embedding = OllamaEmbeddings(model="bge-m3")
-    embedding = OllamaEmbeddings(model="qwen3-embedding:8b")
-    
-    # 4. Chroma 벡터DB 객체 생성 (데이터는 아직 넣지 않음)
+    print(f"Ollama {EMBEDDING_MODEL} 모델을 준비 중입니다...")
+    embedding = OllamaEmbeddings(model=EMBEDDING_MODEL)
+
+    # 4. Chroma 벡터DB 객체 생성
     db = Chroma(persist_directory=persist_directory, embedding_function=embedding)
 
     # 5. 배치 단위로 잘라서 DB에 적재하며 진행 상황(tqdm) 표시
     print("\n본격적인 임베딩 및 DB 적재를 시작합니다:")
-    
-    # range(0, 전체개수, 배치크기)를 tqdm으로 감싸서 루프를 돕니다.
     for i in tqdm(range(0, len(docs), batch_size), desc="임베딩 진행률", unit="batch"):
         batch_docs = docs[i : i + batch_size]
         batch_ids = ids[i : i + batch_size]
-        
-        # 배치만큼 DB에 추가
         db.add_documents(documents=batch_docs, ids=batch_ids)
 
     print(f"\n✅ Ingest completed: 총 {len(docs)}개 청크 저장 완료 -> {persist_directory}")
@@ -70,19 +40,18 @@ def ingest(json_path: str, persist_directory: str, batch_size: int = 100) -> Non
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
-        description="전처리된 JSON 데이터를 Chroma 벡터DB에 적재하는 스크립트 (진행 상황 표시)"
+        description="전처리된 JSON 데이터를 Chroma 벡터DB에 적재하는 스크립트"
     )
     parser.add_argument(
         "--json-path",
-        default="rag_preprocessed_data.json",
-        help="적재할 JSON 파일 경로 (기본값: rag_preprocessed_data.json)",
+        default=RAG_JSON_PATH,
+        help=f"적재할 JSON 파일 경로 (기본값: {RAG_JSON_PATH})",
     )
     parser.add_argument(
         "--persist-directory",
-        default="./chroma_db",
-        help="Chroma DB 저장 경로 (기본값: ./chroma_db)",
+        default=CHROMA_DB_DIR,
+        help=f"Chroma DB 저장 경로 (기본값: {CHROMA_DB_DIR})",
     )
-    # 배치 사이즈를 인자로 받을 수 있게 추가 (기본 100)
     parser.add_argument(
         "--batch-size",
         type=int,
@@ -95,7 +64,7 @@ def parse_args() -> argparse.Namespace:
 if __name__ == "__main__":
     args = parse_args()
     ingest(
-        json_path=args.json_path, 
-        persist_directory=args.persist_directory, 
-        batch_size=args.batch_size
-    )
\ No newline at end of file
+        json_path=args.json_path,
+        persist_directory=args.persist_directory,
+        batch_size=args.batch_size,
+    )
diff --git a/requirements.txt b/requirements.txt
index d231fb5..2ef4455 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,17 +1,17 @@
-streamlit
-pandas
-langchain
-langchain-core
-langchain-community
-langchain-ollama
-langchain-text-splitters
-langchain-classic
-langchain-chroma
-chromadb
-tqdm
-rank_bm25
-sentence-transformers
-transformers
-torch
-bitsandbytes
-accelerate
+streamlit>=1.30
+pandas>=2.0
+langchain>=0.3
+langchain-core>=0.3
+langchain-community>=0.3
+langchain-ollama>=0.2
+langchain-text-splitters>=0.3
+langchain-classic>=0.1
+langchain-chroma>=0.2
+chromadb>=0.5
+tqdm>=4.60
+rank_bm25>=0.2
+sentence-transformers>=3.0
+transformers>=4.40
+torch>=2.0
+bitsandbytes>=0.43
+accelerate>=0.30
diff --git a/retriever.py b/retriever.py
new file mode 100644
index 0000000..f41f855
--- /dev/null
+++ b/retriever.py
@@ -0,0 +1,86 @@
+import json
+import os
+from pathlib import Path
+
+from langchain_core.documents import Document
+from langchain_chroma import Chroma
+from langchain_ollama import OllamaEmbeddings
+
+from config import (
+    RAG_JSON_PATH, CHROMA_DB_DIR, EMBEDDING_MODEL,
+    RERANKER_MODEL, RERANKER_TOP_N,
+    BM25_K, VECTOR_K, ENSEMBLE_WEIGHTS,
+)
+
+
+def load_documents(path=RAG_JSON_PATH):
+    """미리 전처리된 JSON 데이터를 읽어 LangChain Document 리스트로 변환합니다."""
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"데이터 파일({path})이 없습니다.")
+    with open(path, "r", encoding="utf-8") as f:
+        raw = json.load(f)
+    docs = []
+    for item in raw:
+        content = f"제목: {item.get('title', '')}\n내용: {item.get('content_chunk', '')}"
+        metadata = {
+            "chunk_id": item.get("chunk_id", ""),
+            "title": item.get("title", ""),
+            "url": item.get("url", "")
+        }
+        docs.append(Document(page_content=content.strip(), metadata=metadata))
+    return docs
+
+
+def load_vectorstore(persist_directory=CHROMA_DB_DIR):
+    """Chroma 벡터DB를 로드합니다."""
+    if not Path(persist_directory).exists():
+        raise FileNotFoundError("벡터DB가 아직 생성되지 않았습니다. 데이터를 먼저 임베딩하세요.")
+    embed = OllamaEmbeddings(model=EMBEDDING_MODEL)
+    return Chroma(persist_directory=persist_directory, embedding_function=embed)
+
+
+def init_retrievers(docs, vector_db):
+    """Hybrid (BM25 + Vector) 검색 + Cross-Encoder Reranker를 초기화합니다."""
+    import torch
+    from langchain_community.retrievers import BM25Retriever
+    from langchain_classic.retrievers import EnsembleRetriever, ContextualCompressionRetriever
+    from langchain_community.cross_encoders import HuggingFaceCrossEncoder
+    from langchain_classic.retrievers.document_compressors import CrossEncoderReranker
+
+    bm25 = BM25Retriever.from_documents(docs)
+    bm25.k = BM25_K
+    vect = vector_db.as_retriever(search_kwargs={"k": VECTOR_K})
+    hybrid = EnsembleRetriever(retrievers=[bm25, vect], weights=ENSEMBLE_WEIGHTS)
+
+    if "Qwen" in RERANKER_MODEL:
+        model_kwargs = {
+            "automodel_args": {
+                "torch_dtype": torch.float16,
+                "trust_remote_code": True,
+            }
+        }
+    else:
+        model_kwargs = {"model_kwargs": {"torch_dtype": torch.float16}}
+
+    model = HuggingFaceCrossEncoder(model_name=RERANKER_MODEL, model_kwargs=model_kwargs)
+    re_ranker = CrossEncoderReranker(model=model, top_n=RERANKER_TOP_N)
+    return ContextualCompressionRetriever(base_compressor=re_ranker, base_retriever=hybrid)
+
+
+def format_docs_and_extract_urls(docs):
+    """검색된 문서를 텍스트화하고 고유 URL 하이퍼링크를 추출합니다."""
+    context_parts = []
+    unique_refs = {}
+
+    for d in docs:
+        title = d.metadata.get('title', '제목 없음')
+        url = d.metadata.get('url', '')
+        context_parts.append(f"[출처: {title}]\n{d.page_content}")
+        if url and url not in unique_refs:
+            unique_refs[url] = title
+
+    context_str = "\n\n---\n\n".join(context_parts)
+    ref_list = [f"- [{title}]({url})" for url, title in unique_refs.items()]
+    refs_str = "\n".join(ref_list)
+
+    return context_str, refs_str
diff --git a/text_utils.py b/text_utils.py
new file mode 100644
index 0000000..0b5c3ab
--- /dev/null
+++ b/text_utils.py
@@ -0,0 +1,29 @@
+import re
+
+
+FORBIDDEN_TAGS = [
+    "thought", "references", "conclusion", "answer",
+    "response", "output", "result", "context", "question",
+]
+
+
+def clean_response(text: str) -> str:
+    """불필요한 XML 태그를 제거하고 과도한 빈 줄을 정리합니다."""
+    for tag in FORBIDDEN_TAGS:
+        text = re.sub(rf"</?{tag}>", "", text, flags=re.IGNORECASE)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def extract_think_and_answer(text: str):
+    """문자열에서 <think> 부분과 실제 답변 부분을 완벽하게 분리합니다."""
+    if "<think>" in text and "</think>" in text:
+        parts = text.split("</think>", 1)
+        think_content = parts[0].split("<think>")[-1].strip()
+        answer_content = clean_response(parts[1])
+        return think_content, answer_content
+    elif "<think>" in text:
+        think_content = text.split("<think>")[-1].strip()
+        return think_content, ""
+    else:
+        return "", clean_response(text)