Update app.py

app.py

@@ -1,6 +1,5 @@
 """
-PLOBIN - 문서 속 답을 찾아주는 AI 비서
-
+PLOBIN 
 """
 import streamlit as st
 import streamlit.components.v1 as components
@@ -17,65 +16,42 @@ from typing import List, Dict, Tuple
 import base64
 from dotenv import load_dotenv
 import json
-
-import base64
+from difflib import SequenceMatcher
 
 def get_svg_content(svg_path):
     with open(svg_path, "r", encoding="utf-8") as f:
         return f.read()
 
-# 파일 상단에서 한 번만 로드
 plobin_logo_svg = get_svg_content("img/plobin.svg")
 
-# 환경 변수 로드
 load_dotenv()
 
-# Configuration
 GROK_API_KEY = os.getenv("GROK_API_KEY")
 GROK_API_BASE = "https://api.x.ai/v1"
 CHROMA_DIR = "./chroma_db"
 EMBEDDING_MODEL = 'jhgan/ko-sroberta-multitask'
 
-# ==================== 하이라이트 설정 클래스 ====================
 class HighlightConfig:
-    """하이라이트 설정 - 노란색 고정"""
-    
     def __init__(self):
-        # 하이라이트 색상 - 노란색 고정
-        self.color = [1.0, 1.0, 0.0]  # 노란색 (RGB 0-1 범위)
+        self.color = [1.0, 1.0, 0.0]
 
-# Page config
 st.set_page_config(
     page_title="PLOBIN",
-    page_icon="🔮",
+    page_icon="img/plobin-left-only.png",
     layout="wide",
     initial_sidebar_state="expanded"
 )
 
-# 사이드바 기존
-            #667eea 0%, 
-            #764ba2 100%);
-
-# 사이드바 1안
-            #5ECFFF 0%, 
-            #B8FF6E 100%);
-
-# 사이드바 2안
-            #258CFF 0%, 
-            #0A1E6A 100%);
-
-# Custom CSS
 st.markdown("""
 <style>
     [data-testid="stSidebar"] {
         background: linear-gradient(180deg, 
-            #90B9E8 0%, 
-            #B3BEC9 100%);
+            #618FC2 0%, 
+            #8E969E 100%);
         box-shadow: 4px 0 30px rgba(0,0,0,0.2);
         width: 290px !important;
     }
     
-    /* 사이드바 타이틀 빛나는 효과 */
     [data-testid="stSidebar"] h1 {
         color: white !important;
         font-weight: 900 !important;
@@ -87,7 +63,6 @@ st.markdown("""
         letter-spacing: 2px;
     }
     
-    /* 사이드바 타이틀 애니메이션 */
     @keyframes sidebarTitlePulse {
         0%, 100% {
             transform: scale(1);
@@ -106,7 +81,6 @@ st.markdown("""
         }
     }
     
-    /* 파일 업로더 배경 투명하게 */
     [data-testid="stSidebar"] [data-testid="stFileUploader"] {
         background: rgba(255,255,255,0.15);
         border-radius: 15px;
@@ -116,37 +90,34 @@ st.markdown("""
         backdrop-filter: blur(10px);
     }
     
-    /* 파일 업로더 내부 섹션도 투명하게 */
     [data-testid="stFileUploader"] > section {
         background: transparent !important;
     }
     
-    /* 파일 업로더 드래그 영역 */
     [data-testid="stFileUploader"] > section > div {
         background: transparent !important;
     }
     
-    /* 업로드된 파일 표시 영역 */
     [data-testid="stFileUploader"] [data-testid="stMarkdownContainer"] {
         color: #fafafa;
     }
-    /* 하얀 박스(드롭존) 스타일 */
+    
     [data-testid="stSidebar"] [data-testid="stFileUploader"] > section,
     [data-testid="stSidebar"] [data-testid="stFileUploader"] section > div {
         background: transparent !important;
         border: none !important;
     }
-    /* 드롭존 내부 텍스트 색상 */
+    
     [data-testid="stSidebar"] [data-testid="stFileUploader"] [data-testid="stMarkdownContainer"] p {
         color: rgba(255,255,255,0.9) !important;
     }
-    /* "파일 찾기" 버튼 */
+    
     [data-testid="stSidebar"] [data-testid="stFileUploader"] button[kind="secondary"] {
         background: rgba(255,255,255,0.2) !important;
         color: white !important;
         border: 1px solid rgba(255,255,255,0.3) !important;
     }
-    /* 사이드바 버튼 스타일 업데이트 */
+    
     [data-testid="stSidebar"] .stButton button {
         background: rgba(255,255,255,0.15) !important;
         color: white !important;
@@ -158,48 +129,53 @@ st.markdown("""
         transition: all 0.3s ease !important;
         box-shadow: 0 4px 15px rgba(0,0,0,0.1) !important;
     }
+    
     [data-testid="stSidebar"] .stButton button:hover {
         background: rgba(255,255,255,0.25) !important;
         border-color: rgba(255,255,255,0.6) !important;
         transform: translateY(-2px) scale(1.02) !important;
         box-shadow: 0 6px 20px rgba(0,0,0,0.2) !important;
     }
+    
     [data-testid="stSidebar"] .stButton button:active {
         transform: translateY(0px) scale(0.98) !important;
     }
-    /* Primary 버튼 (문서 처리 시작) 특별 스타일 */
+    
     [data-testid="stSidebar"] .stButton button[kind="primary"] {
         background: rgba(255,255,255,0.25) !important;
         border: 2px solid rgba(255,255,255,0.5) !important;
         font-size: 1.05rem !important;
     }
+    
     [data-testid="stSidebar"] .stButton button[kind="primary"]:hover {
         background: rgba(255,255,255,0.35) !important;
         border-color: rgba(255,255,255,0.7) !important;
     }
+    
     [data-testid="stSidebar"] [data-testid="stAlert"] {
         background-color: rgba(255, 255, 255, 0.001) !important;
         border-radius: 0.5rem !important;
     }
+    
     [data-testid="stAlert"] p {
-        color: rgb(250, 250, 250);  /* 흰색 */
+        color: rgb(250, 250, 250);
     }
-    /* 메인 컨텐츠 전체 너비 사용 */
+    
     .main .block-container {
         max-width: 100%;
         padding-left: 2rem;
         padding-right: 2rem;
     }
     
-    /* 헤더 스타일 - 박스 제거, 텍스트 그림자만 */
     .plobin-header {
         padding: 1.5rem 2rem;
         margin-bottom: 2rem;
     }
+    
     .plobin-logo {
         display: block;
         margin: 0 auto;
-        height: 60px;  /* 원하는 크기로 조정 */
+        height: 60px;
     }
 
     .plobin-title {
@@ -211,6 +187,7 @@ st.markdown("""
         text-shadow: 2px 2px 8px rgba(0, 0, 0, 0.4),
                     0 0 20px rgba(102, 126, 234, 0.4);
     }
+    
     .plobin-subtitle {
         font-size: 1rem;
         color: rgba(255, 255, 255, 0.9);
@@ -219,7 +196,6 @@ st.markdown("""
         text-shadow: 1px 1px 6px rgba(0, 0, 0, 0.4);
     }
     
-    /* 파일 업로더 커스터마이징 */
     [data-testid="stFileUploader"] {
         background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
         border: 3px dashed #667eea;
@@ -237,17 +213,15 @@ st.markdown("""
         font-weight: 600 !important;
     }
     
-    /* PDF 컨테이너 */
     .pdf-container {
         border: 2px solid #E2E8F0;
         border-radius: 0.5rem;
         padding: 0.5rem;
-        height: 705px;
+        height: 706px;
         overflow-y: auto;
         background: white;
     }
     
-    /* 채팅 컨테이너 - 스크롤 추가 */
     .chat-container {
         border: 2px solid #E2E8F0;
         border-radius: 0.5rem;
@@ -258,13 +232,11 @@ st.markdown("""
         margin-bottom: 0.5rem;
     }
     
-    /* 채팅 입력창과 컨테이너 간격 최소화 */
     [data-testid="stChatInput"] {
         margin-top: 0 !important;
         padding-top: 0 !important;
     }
     
-    /* 채팅 스타일 */
     .source-box {
         background: #F1F5F9;
         padding: 1rem;
@@ -299,7 +271,6 @@ st.markdown("""
         border-left: 4px solid #EAB308;
     }
     
-    /* 사용 안내 스타일 */
     .usage-guide {
         background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
         padding: 2rem;
@@ -332,7 +303,6 @@ st.markdown("""
         flex-shrink: 0;
     }
     
-    /* 뷰어 헤더 스타일 */
     .viewer-header {
         display: flex;
         justify-content: space-between;
@@ -340,7 +310,6 @@ st.markdown("""
         margin-bottom: 1rem;
     }
     
-    /* 페이지 선택 애니메이션 */
     @keyframes pulse {
         0%, 100% {
             box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.7);
@@ -350,7 +319,6 @@ st.markdown("""
         }
     }
     
-    /* 채팅 타이틀 스타일 (애니메이션 제거) */
     .chat-title {
         color: black !important;
         font-weight: 900 !important;
@@ -363,7 +331,6 @@ st.markdown("""
         letter-spacing: 2px;
     }
     
-    /* 채팅 내 페이지 번호 버튼 스타일 - 클릭 가능한 박스처럼 */
     [data-testid="column"] button[kind="secondary"] {
         background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
         color: white !important;
@@ -408,7 +375,6 @@ st.markdown("""
 
 
 def init_session():
-    """세션 상태 초기화"""
     if 'processed' not in st.session_state:
         st.session_state.processed = False
     if 'vector_db' not in st.session_state:
@@ -436,13 +402,6 @@ def init_session():
 
 
 def extract_text_from_pdf(pdf_file) -> Tuple[List[str], List[Dict], bytes, Dict]:
-    """
-    PDF에서 텍스트 추출
-    
-    수정 사항:
-    - CHUNK_SIZE: 300 → 800
-    - OVERLAP_SIZE: 60 → 150
-    """
     pdf_bytes = pdf_file.read()
     doc = fitz.open(stream=pdf_bytes, filetype="pdf")
     
@@ -450,10 +409,8 @@ def extract_text_from_pdf(pdf_file) -> Tuple[List[str], List[Dict], bytes, Dict]
     metadata_list = []
     pages_text = {}
     
-    # ==================== 수정된 청크 설정 ====================
-    CHUNK_SIZE = 800     # 300에서 800으로 증가
-    OVERLAP_SIZE = 150   # 60에서 150으로 증가
-    # ========================================================
+    CHUNK_SIZE = 800
+    OVERLAP_SIZE = 150
     
     for page_num in range(len(doc)):
         page = doc[page_num]
@@ -504,15 +461,12 @@ def extract_text_from_pdf(pdf_file) -> Tuple[List[str], List[Dict], bytes, Dict]
 
 @st.cache_resource
 def load_embedding_model():
-    """임베딩 모델 로드"""
     return SentenceTransformer(EMBEDDING_MODEL)
 
 
 def create_vector_db(chunks: List[str], metadata_list: List[Dict]):
-    """벡터 데이터베이스 생성 - 메모리 기반으로 안정성 향상"""
     embedder = load_embedding_model()
     
-    # 메모리 기반 ChromaDB 사용 (파일 시스템 문제 회피)
     client = chromadb.EphemeralClient(
         settings=chromadb.Settings(
             anonymized_telemetry=False,
@@ -520,7 +474,6 @@ def create_vector_db(chunks: List[str], metadata_list: List[Dict]):
         )
     )
     
-    # 컬렉션 생성
     try:
         client.delete_collection("rfx_docs")
     except Exception:
@@ -531,7 +484,6 @@ def create_vector_db(chunks: List[str], metadata_list: List[Dict]):
         metadata={"hnsw:space": "cosine"}
     )
     
-    # 배치 임베딩
     batch_size = 32
     all_embeddings = []
     
@@ -551,57 +503,32 @@ def create_vector_db(chunks: List[str], metadata_list: List[Dict]):
     return collection, embedder
 
 
-# ==================== 의미 기반 키워드 추출 (하드코딩 제거) ====================
 def extract_keywords_semantic(text: str, embedder, top_n: int = 5) -> List[str]:
-    """
-    의미 기반 키워드 추출 - 불용어 리스트 불필요
-    
-    원리:
-    1. 숫자 포함 단어는 무조건 중요하게 취급
-    2. 원본 텍스트의 의미와 각 단어의 의미 유사도 계산
-    3. 유사도 × 빈도수로 점수 산정
-    4. 점수순으로 상위 키워드 추출
-    """
-    # 1. 숫자 포함 단어는 무조건 포함 (금액, 날짜, 수량 등)
     words_with_numbers = re.findall(r'[가-힣]*\d+[가-힣]*', text)
-    
-    # 2. 명사구 추출 (2글자 이상)
     candidate_words = re.findall(r'[가-힣]{2,}', text)
     
     if not candidate_words:
         return words_with_numbers[:top_n]
     
     word_freq = Counter(candidate_words)
-    
-    # 3. 원본 텍스트와 각 단어의 의미 유사도 계산
     text_embedding = embedder.encode([text], convert_to_numpy=True)[0]
     word_embeddings = embedder.encode(list(word_freq.keys()), convert_to_numpy=True)
-    
-    # 코사인 유사도 계산
     similarities = util.cos_sim(text_embedding, word_embeddings)[0].numpy()
     
-    # 4. 점수 = 의미유사도 × 빈도수 (빈도는 로그 스케일)
     scored_words = []
     for idx, (word, freq) in enumerate(word_freq.items()):
-        # 의미 유사도 70% + 빈도 30%
         semantic_score = similarities[idx]
-        frequency_score = np.log1p(freq) / 10.0  # 빈도에 로그 적용 후 정규화
-        
+        frequency_score = np.log1p(freq) / 10.0
         combined_score = 0.7 * semantic_score + 0.3 * frequency_score
         scored_words.append((word, combined_score))
     
-    # 5. 점수순 정렬
     scored_words.sort(key=lambda x: x[1], reverse=True)
     
-    # 6. 결과 조합: 숫자 포함 단어 우선 + 의미 점수 높은 단어
     result = []
-    
-    # 숫자 포함 단어 먼저 추가 (최대 3개)
     for word in words_with_numbers[:3]:
         if word and word not in result:
             result.append(word)
     
-    # 나머지를 의미 점수로 채움
     for word, score in scored_words:
         if word not in result:
             result.append(word)
@@ -611,28 +538,22 @@ def extract_keywords_semantic(text: str, embedder, top_n: int = 5) -> List[str]:
     return result[:top_n]
 
 
-# ==================== 하이브리드 검색 함수 (의미 기반 키워드 사용) ====================
 def hybrid_search(query: str, collection, embedder, top_k: int = 3) -> Dict:
-    """하이브리드 검색: 벡터 유사도 + 의미 기반 키워드 매칭"""
-    # 1. 벡터 검색
     query_embedding = embedder.encode([query], convert_to_numpy=True)[0]
     vector_results = collection.query(
         query_embeddings=[query_embedding.tolist()],
-        n_results=20,  # 많이 가져와서 키워드로 필터링
+        n_results=20,
         include=["documents", "metadatas", "distances"]
     )
     
-    # 2. 의미 기반 키워드 추출 (하드코딩 제거)
     keywords = extract_keywords_semantic(query, embedder, top_n=5)
     
-    # 3. 하이브리드 점수 계산
     hybrid_results = []
     for i, doc_id in enumerate(vector_results['ids'][0]):
         doc = vector_results['documents'][0][i]
         metadata = vector_results['metadatas'][0][i]
-        vector_score = 1 - vector_results['distances'][0][i]  # 거리를 유사도로 변환
+        vector_score = 1 - vector_results['distances'][0][i]
         
-        # 키워드 매칭 점수
         keyword_score = 0
         doc_lower = doc.lower()
         for keyword in keywords:
@@ -640,7 +561,6 @@ def hybrid_search(query: str, collection, embedder, top_k: int = 3) -> Dict:
                 keyword_score += 1
         keyword_score = keyword_score / len(keywords) if keywords else 0
         
-        # 하이브리드 점수 (벡터 70% + 키워드 30%)
         hybrid_score = 0.7 * vector_score + 0.3 * keyword_score
         
         hybrid_results.append({
@@ -652,7 +572,6 @@ def hybrid_search(query: str, collection, embedder, top_k: int = 3) -> Dict:
             'keyword_score': keyword_score
         })
     
-    # 4. 점수순 정렬 후 상위 k개
     hybrid_results.sort(key=lambda x: x['hybrid_score'], reverse=True)
     top_results = hybrid_results[:top_k]
     
@@ -664,13 +583,10 @@ def hybrid_search(query: str, collection, embedder, top_k: int = 3) -> Dict:
     }
 
 
-# ==================== Grok API 점검 함수 ====================
 def grok_verify_and_extract(query: str, search_results: Dict, api_key: str) -> Dict:
-    """Grok API로 검색 결과 점검 및 최종 1개만 선택"""
     docs = search_results['documents'][0]
     metas = search_results['metadatas'][0]
     
-    # 문서들을 번호와 함께 포맷팅
     formatted_docs = []
     for i, (doc, meta) in enumerate(zip(docs, metas), 1):
         formatted_docs.append(f"[문서 {i}] (페이지 {meta['page']})\n{doc}")
@@ -734,9 +650,6 @@ def grok_verify_and_extract(query: str, search_results: Dict, api_key: str) -> D
         
         result = response.json()
         content = result["choices"][0]["message"]["content"]
-        
-        # JSON 파싱
-        # markdown 코드 블록 제거
         content = content.replace("```json", "").replace("```", "").strip()
         extracted_data = json.loads(content)
         
@@ -747,7 +660,6 @@ def grok_verify_and_extract(query: str, search_results: Dict, api_key: str) -> D
 
 
 def build_context(search_results: Dict, max_length: int = 3000) -> str:
-    """컨텍스트 구성"""
     context_parts = []
     current_length = 0
     
@@ -772,7 +684,6 @@ def build_context(search_results: Dict, max_length: int = 3000) -> str:
 
 
 def generate_answer(query: str, search_results: Dict, api_key: str) -> str:
-    """답변 생성"""
     context = build_context(search_results, max_length=4000)
     
     system_prompt = """당신은 자동차 제조업 RFx 문서 전문 분석가입니다.
@@ -781,49 +692,51 @@ def generate_answer(query: str, search_results: Dict, api_key: str) -> str:
 2. **언어 혼용 및 비문 대응**: 사용자의 문장은 한국어와 영어가 섞이거나 문법 오류가 있을 수 있으므로 의도를 추론하여 정확히 이해하라.
 3. **모호한 질문 자동 보정**: 사용자의 질문이 불완전하거나 모호해도 질문 의도를 추론하여 적절하게 재구성하라.
 **문서 기반 응답 원칙 (절대 추측 금지):**
-1. 제공된 문서를 **매우 �꼼히** 읽고 정확한 정보를 찾으세요
+1. 제공된 문서를 **매우 꼼꼼히** 읽고 정확한 정보를 찾으세요
 2. **반드시 문서에서 근거를 찾아 답변**하고, 문서에 없는 내용은 임의로 추측하지 말고 **"문서에서 관련 정보를 찾을 수 없습니다"**라고 명시하라
 3. **문서와 전혀 무관한 질문**(예: 점심 추천, 날씨, 일상 대화 등)은 **"죄송하지만, 제공된 문서에는 해당 질문과 관련된 정보가 포함되어 있지 않습니다."**라고만 답변하고 추가 설명 없이 종료하라
 4. 문서에 정보가 있는데도 "없다"고 하지 마세요
 **핵심 정보 우선 추출:**
 - 금액, 수량, 규격, 일정, 요구조건 등 **수치 기반 정보를 최우선**으로 식별하고 정확하게 반환하라
 - 숫자, 금액, 날짜 등 구체적인 정보를 우선적으로 찾으세요
-- 애매한 표현 대신 구체적인 수치를 제공하세요
-**방대한 문서 처리 (500페이지 가능):**
-- 문서가 매우 길 수 있으므로 질문과 직접 관련된 부분만 선별해 요약하고 핵심 정보만 사용하라
-**실무 맥락 고려 (RFx 프로세스 특화):**
-- 답변할 때 실제 자동차 RFx 실무자가 의사결정에 사용하는 정보라는 점을 고려하여 실무 중심으로 명확하게 설명하라
-- 특히 다음 항목들을 우선적으로 파악하라:
-  1. 사업 참여 자격 및 요구 인증
-  2. 사업 기간 및 일정
-  3. 예산 (현금/현물 비중, 순수 회사 수익 가능성)
-  4. 제안요청서 사양서 – 필요한 기술적 요구사항(서버/소프트웨어 등)
-  5. 판매 대상 및 사업 범위
 **답변 형식:**
-- 답변 시 반드시 **[페이지 X]** 형태로 출처를 명시하세요 (예: [페이지 3], [페이지 5, 12])
-- 관련 문맥을 유지하며, 답변에는 문서의 페이지 번호와 원문 일부를 정확히 인용하라
+- 답변 시 반드시 **[페이지 X]** 형태로 출처를 명시하세요
+- **절대 중요**: "문서 1", "문서 2" 같은 표기는 절대 사용하지 마세요
 - 핵심 답변을 먼저 명확하게 제시
-- 필요시 추가 관련 정보 제공
-- 리스트는 - 또는 번호를 사용
-- 강조는 **굵게** 또는 *기울임* 사용
-- **답변은 반드시 마크다운만 사용해야 하며, HTML 태그(<div>, <span>, <details>, <summary> 등)는 절대 사용하지 마십시오**"""
-    
-    user_prompt = f"""다음 문서들을 **매우 꼼꼼히** 읽고 질문에 답변하세요.
+- 마크다운 형식으로만 답변하세요
+- 질문에 따라 가장 적절한 구조로 답변하세요 (단계별, 카테고리별, 시간순 등)
+
+**원문 인용 규칙 (하이라이트용):**
+- 핵심 내용을 설명할 때는 큰따옴표("")로 PDF 원문을 그대로 인용하세요
+- 큰따옴표 안의 내용은 PDF 원문을 **한 글자도 바꾸지 말고** 그대�� 복사
+- 문장 종결어("~함", "~임", "~요청함" 등)도 원문 그대로 유지
+- 인용 예시: "기술평가 점수가 배점한도(100점)의 85% 이상인 자를 기술평가 적격자로 선정" [페이지 9]
+- 원문 인용 후 필요하면 부연 설명 추가 가능"""
+    
+    user_prompt = f"""다음 문서들을 매우 꼼꼼히 읽고 질문에 답변하세요.
+
 <문서>
 {context}
 </문서>
+
 <질문>
 {query}
 </질문>
-**중요**: 
-- 질문이 문서와 전혀 무관한 경우(예: 점심 추천, 날씨, 일상 대화 등) "죄송하지만, 제공된 문서에는 해당 질문과 관련된 정보가 포함되어 있지 않습니다."라고만 답변하세요
-- 문서를 처음부터 끝까지 주의 깊게 읽으세요
-- 숫자, 금액 등 구체적인 정보를 찾으세요
-- 찾은 정보는 정확히 인용하세요
-- 출처는 반드시 [페이지 X] 형태로 표시하세요 (예: [페이지 3])
-- 여러 페이지에서 정보를 찾은 경우 [페이지 3, 5, 12] 형태로 표시하세요
-- 정말로 문서에 없는 경우에만 "문서에서 관련 정보를 찾을 수 없습니다"라고 하세요
-- 마크다운 형식으로만 답변하고, HTML 태그는 절대 사용하지 마세요"""
+
+**답변 작성 가이드:**
+
+1. **구조화**: 질문 유형에 맞는 가장 읽기 쉬운 구조 선택
+   - 절차/프로세스 질문 → 단계별 번호 (1, 2, 3...)
+   - 항목 나열 질문 → 불릿 포인트 (• 또는 *)
+   - 비교/선택 질문 → 카테고리별 구분
+
+2. **원문 인용**: 핵심 내용은 큰따옴표로 PDF 원문 그대로 인용
+   - 예: "기술평가 적격자를 대상으로 가격 입찰을 실시하여, 한국자동차연구원의 예정가격이하 최저가격 투찰자를 낙찰자로 선정" [페이지 9]
+   - 큰따옴표 안 = 원문 그대로 (절대 의역 금지)
+
+3. **출처 표기**: 모든 정보에 [페이지 X] 표기
+
+4. **형식**: 마크다운만 사용, "문서 1" 같은 표기 금지"""
     
     headers = {
         "Content-Type": "application/json",
@@ -857,7 +770,7 @@ def generate_answer(query: str, search_results: Dict, api_key: str) -> str:
             except Exception:
                 error_detail = response.text
             
-            return f"❌ API 오류 (코드: {response.status_code})\n\n{error_detail}"
+            return f"❌ API 오류 (코드: {response.status_code})\n상세: {error_detail}"
         
         result = response.json()
         return result["choices"][0]["message"]["content"]
@@ -867,50 +780,145 @@ def generate_answer(query: str, search_results: Dict, api_key: str) -> str:
 
 
 def highlight_text_in_pdf(pdf_bytes: bytes, highlight_info: List[Dict]) -> bytes:
-    """PDF에 텍스트 하이라이트 추가 - 노란색 고정"""
+    """
+    문장 단위로 쪼개서 각각 찾은 뒤 모두 하이라이트 (더 공격적)
+    """
     doc = fitz.open(stream=pdf_bytes, filetype="pdf")
-    
-    # 노란색 고정
     yellow_color = [1.0, 1.0, 0.0]
     
+    def normalize_text(text):
+        return re.sub(r'\s+', ' ', text.strip().lower())
+    
+    def find_text_fuzzy(page, search_text, threshold=0.65):
+        """퍼지 매칭으로 텍스트 영역 찾기 (임계값 낮춤)"""
+        search_norm = normalize_text(search_text)
+        
+        # 1. 정확한 매칭 시도
+        variations = [
+            search_text,
+            search_text.replace(' ', ''),
+            search_text.replace('\n', ' '),
+            search_text.replace(',', ''),
+        ]
+        
+        for var in variations:
+            instances = page.search_for(var)
+            if instances:
+                return instances
+        
+        # 2. 블록 단위 퍼지 매칭
+        blocks = page.get_text("blocks")
+        for block in blocks:
+            if len(block) < 5:
+                continue
+            
+            block_text = block[4]
+            block_norm = normalize_text(block_text)
+            
+            similarity = SequenceMatcher(None, search_norm, block_norm).ratio()
+            if similarity >= threshold:
+                return [fitz.Rect(block[0], block[1], block[2], block[3])]
+        
+        # 3. 단어 단위 매칭
+        words = page.get_text("words")
+        if not words:
+            return []
+        
+        search_words = search_norm.split()
+        min_words = max(2, len(search_words) // 3)  # 1/3만 매칭되어도 OK
+        
+        best_match = None
+        best_sim = 0.0
+        
+        for i in range(len(words)):
+            for size in range(len(search_words), min_words - 1, -1):
+                if i + size > len(words):
+                    continue
+                
+                window = words[i:i + size]
+                window_text = " ".join([w[4] for w in window])
+                window_norm = normalize_text(window_text)
+                
+                sim = SequenceMatcher(None, search_norm, window_norm).ratio()
+                if sim > best_sim and sim >= threshold:
+                    best_sim = sim
+                    rect = fitz.Rect(window[0][:4])
+                    for w in window[1:]:
+                        rect = rect | fitz.Rect(w[:4])
+                    best_match = rect
+        
+        if best_match:
+            return [best_match]
+        
+        return []
+    
     for item in highlight_info:
         page_num = item['page'] - 1
-        search_text = item['text']
+        full_text = item['text'].strip()
         
         if page_num >= len(doc):
             continue
         
         page = doc[page_num]
         
-        text_variations = [
-            search_text,
-            search_text.replace(' ', ''),
-            search_text.replace(',', ''),
-        ]
+        # 전략 1: 마침표 기준으로 분리 (쉼표 무시)
+        sentences = re.split(r'([.。]\s*)', full_text)
+        sentences = [s.strip() for s in sentences if s.strip() and len(s.strip()) > 1]
+        
+        # 마침표를 앞 문장에 붙이기
+        combined = []
+        i = 0
+        while i < len(sentences):
+            if i + 1 < len(sentences) and sentences[i+1] in ['.', '。']:
+                combined.append(sentences[i] + sentences[i+1])
+                i += 2
+            else:
+                combined.append(sentences[i])
+                i += 1
         
-        for text_var in text_variations:
-            text_instances = page.search_for(text_var)
+        # 각 문장을 개별적으로 찾기 (8자 이상)
+        found_any = False
+        for sentence in combined:
+            if len(sentence) < 8:  # 10자 → 8자로 낮춤
+                continue
             
-            for inst in text_instances:
-                highlight = page.add_highlight_annot(inst)
+            rects = find_text_fuzzy(page, sentence, threshold=0.60)  # 0.70 → 0.60
+            if rects:
+                found_any = True
+                for rect in rects:
+                    highlight = page.add_highlight_annot(rect)
+                    highlight.set_colors(stroke=yellow_color)
+                    highlight.update()
+        
+        # 전략 2: 문장별로 안 되면 전체를 더 낮은 임계값으로
+        if not found_any:
+            rects = find_text_fuzzy(page, full_text, threshold=0.50)  # 0.60 → 0.50
+            for rect in rects:
+                highlight = page.add_highlight_annot(rect)
                 highlight.set_colors(stroke=yellow_color)
                 highlight.update()
+        
+        # 전략 3: 그래도 안 되면 핵심 키워드만이라도 찾기
+        if not found_any:
+            # 10자 이상의 명사구 추출
+            keywords = re.findall(r'[가-힣]{10,}', full_text)
+            for kw in keywords[:3]:  # 상위 3개만
+                rects = find_text_fuzzy(page, kw, threshold=0.70)
+                for rect in rects:
+                    highlight = page.add_highlight_annot(rect)
+                    highlight.set_colors(stroke=yellow_color)
+                    highlight.update()
     
     output_bytes = doc.tobytes()
     doc.close()
-    
     return output_bytes
 
 
-# ==================== Grok 추출 결과 기반 하이라이트 ====================
 def extract_highlights_from_grok(grok_result: Dict) -> List[Dict]:
-    """Grok API가 선택한 최종 1개를 하이라이트 형식으로 변환"""
     if "error" in grok_result:
         return []
     
     highlights = []
-    
-    # 최종 선택된 1개만 처리
     selected_text = grok_result.get("selected_text", "")
     page = grok_result.get("page", 1)
     
@@ -923,73 +931,70 @@ def extract_highlights_from_grok(grok_result: Dict) -> List[Dict]:
     return highlights
 
 
+def extract_highlights_from_answer(answer: str) -> List[Dict]:
+    """
+    답변에서 큰따옴표로 감싼 원문만 추출하여 하이라이트
+    패턴: "PDF 원문" [페이지 X]
+    """
+    import re
+    
+    highlights = []
+    
+    # 큰따옴표로 감싼 인용구 추출
+    # 예: "제안업체는... 제안하여야 함" [페이지 9]
+    pattern = r'"([^"]+)"\s*\[페이지\s+(\d+)\]'
+    matches = re.findall(pattern, answer)
+    
+    for quote, quote_page in matches:
+        highlights.append({
+            'text': quote.strip(),
+            'page': int(quote_page)
+        })
+    
+    return highlights
+
+
 def render_pdf_with_highlights(pdf_bytes: bytes, highlight_info: List[Dict], zoom_level: float = 2.0):
-    """하이라이트된 PDF 렌더링"""
     highlighted_pdf = highlight_text_in_pdf(pdf_bytes, highlight_info)
-    
     doc = fitz.open(stream=highlighted_pdf, filetype="pdf")
-    
     highlighted_pages = set(h['page'] for h in highlight_info)
     
     pdf_html = '<div class="pdf-container" id="pdf-viewer-container">'
     
     for page_num in range(len(doc)):
         page = doc[page_num]
-        
-        # zoom_level을 사용하여 렌더링
         pix = page.get_pixmap(matrix=fitz.Matrix(zoom_level, zoom_level))
         img_data = pix.tobytes("png")
         img_base64 = base64.b64encode(img_data).decode()
         
-        # 실제 이미지 크기 계산 (zoom_level에 따라)
-        zoom_percentage = int(zoom_level * 50)  # 2.0 = 100%, 1.0 = 50%
-        
-        # 각 페이지에 고유 ID 부여
+        zoom_percentage = int(zoom_level * 50)
         page_id = f'page-{page_num + 1}'
         pdf_html += f'<div id="{page_id}" style="margin-bottom: 2rem; position: relative;">'
         
-        # 하이라이트 여부에 따라 페이지 헤더 스타일 변경
         if (page_num + 1) in highlighted_pages:
-            # 하이라이트가 있는 페이지 - 노란 배경
             pdf_html += f'<div style="background: #FEF08A; color: #854D0E; padding: 0.5rem; margin-bottom: 0.5rem; border-radius: 0.3rem; font-weight: bold; border-left: 4px solid #EAB308;">⭐ 페이지 {page_num + 1}</div>'
         else:
-            # 일반 페이지 - 파란 배경
             pdf_html += f'<div style="background: #667eea; color: white; padding: 0.5rem; margin-bottom: 0.5rem; border-radius: 0.3rem; font-weight: bold;">📄 페이지 {page_num + 1}</div>'
         
-        # width를 zoom_percentage로 변경하여 실제 확대/축소 적용
         pdf_html += f'<img src="data:image/png;base64,{img_base64}" style="width: {zoom_percentage}%; border: 1px solid #E2E8F0; border-radius: 0.3rem; box-shadow: 0 1px 3px rgba(0,0,0,0.1); display: block; margin: 0 auto;" />'
         pdf_html += '</div>'
     
     pdf_html += '</div>'
-    
     doc.close()
-    
     return pdf_html
 
 
 def main():
     init_session()
-
     
-    # Header 문서 처리 전에만 보임 
     if not st.session_state.processed:
-        # 로고 가운데 정렬
         col1, col2, col3 = st.columns([1, 1, 1])
         with col2:
             st.image("img/plobin.svg", use_container_width=True)
             st.text(' ')
-        
-        # 서브타이틀
-        # st.markdown("""
-        #     <div style="text-align: center; margin-top: 10px;">
-        #         문서 속 답을 찾아주는 AI 비서
-        #     </div>
-        # """, unsafe_allow_html=True)
-
-    # ========== 사이드바 ==========
+    
     with st.sidebar:
-        st.image("img/plobin-left-only.png", width=30)  # 픽셀 값으로 직접 지정
-        # st.title("🔮 PLOBIN")
+        st.image("img/plobin.svg", width=120)
         
         uploaded_file = st.file_uploader(
             "드래그하여 파일을 업로드 또는 클릭하여 선택하세요.",
@@ -999,22 +1004,21 @@ def main():
         )
 
         if uploaded_file:
-            if st.button("📄 문서 처리 시작", type="primary", use_container_width=True):
+            if st.button("문서 처리 시작", type="primary", use_container_width=True):
                 if not GROK_API_KEY:
                     st.error("⚠️ GROK_API_KEY가 .env 파일에 설정되지 않았습니다!")
                     st.stop()
                 
-                # 기존 세션 초기화
                 st.session_state.vector_db = None
                 st.session_state.embedder = None
                 st.session_state.chat_history = []
                 st.session_state.current_highlights = []
                 
-                with st.spinner("📄 문서 처리 중..."):
+                with st.spinner("문서 처리 중..."):
                     try:
                         chunks, metadata_list, pdf_bytes, pages_text = extract_text_from_pdf(uploaded_file)
                         
-                        with st.spinner("🤖 문서를 AI가 이해할 수 있게 처리 중.."):
+                        with st.spinner("문서를 AI가 이해할 수 있게 처리 중.."):
                             collection, embedder = create_vector_db(chunks, metadata_list)
                         
                         st.session_state.vector_db = collection
@@ -1028,26 +1032,24 @@ def main():
                             "pages": len(set(m['page'] for m in metadata_list))
                         }
                         
-                        st.success("✅ 문서 처리 완료!")
+                        st.success("문서 처리 완료!")
                         st.rerun()
                         
                     except Exception as e:
                         st.error(f"오류: {str(e)}")
         
-        # 문서 정보 표시 (청크 정보 제외)
         if st.session_state.processed:
-            st.markdown("#### 📊 문서 정보")
-            st.info(f"📄 **{st.session_state.doc_metadata['filename']}**")
-            st.info(f"📑 페이지: {st.session_state.doc_metadata['pages']}")
+            st.markdown("#### 문서 정보")
+            st.info(f"**{st.session_state.doc_metadata['filename']}**")
+            st.info(f"페이지: {st.session_state.doc_metadata['pages']}")
     
-    # ===== 아직 문서가 처리되지 않은 경우
     if not st.session_state.processed:
         st.markdown("""
         <div class="usage-guide">
-            <h2 style="text-align: center; color: #2D3748; margin-bottom: 1.5rem;">📖 사용 방법</h2>
+            <h2 style="text-align: center; color: #2D3748; margin-bottom: 1.5rem;">사용 방법</h2>
             <div class="guide-step">
                 <div class="step-number">1</div>
-                <div>📤 PDF 파일을 올려주세요</div>
+                <div>PDF 파일을 올려주세요</div>
             </div>
             <div class="guide-step">
                 <div class="step-number">2</div>
@@ -1064,28 +1066,13 @@ def main():
         </div>
         """, unsafe_allow_html=True)
 
-    # 문서가 처리된 경우: 분석 화면
     else:
-        # 2단 레이아웃
         col1, col2 = st.columns([1, 1])
         
         with col1:
-            # 헤더와 줌 컨트롤을 가로로 나란히
             header_cols = st.columns([7, 1, 1.5, 1])
             with header_cols[0]:
-                st.markdown("### 📄 문서 뷰어")
-            with header_cols[1]:
-                if st.button("➖", key="zoom_out", help="축소", use_container_width=True):
-                    if st.session_state.zoom_level > 0.5:
-                        st.session_state.zoom_level -= 0.25
-                        st.rerun()
-            with header_cols[2]:
-                st.markdown(f"<div style='text-align: center; padding-top: 0.5rem; font-weight: bold;'>{int(st.session_state.zoom_level * 50)}%</div>", unsafe_allow_html=True)
-            with header_cols[3]:
-                if st.button("➕", key="zoom_in", help="확대", use_container_width=True):
-                    if st.session_state.zoom_level < 4.0:
-                        st.session_state.zoom_level += 0.25
-                        st.rerun()
+                st.markdown("### 문서 뷰어")
             
             if st.session_state.pdf_bytes:
                 pdf_html = render_pdf_with_highlights(
@@ -1095,22 +1082,18 @@ def main():
                 )
                 st.markdown(pdf_html, unsafe_allow_html=True)
                 
-                # 스크롤 기능 - JavaScript로 구현
                 if st.session_state.scroll_to_page:
                     scroll_js = f"""
                     <script>
-                        // PDF 컨테이너 찾기
                         const container = parent.document.querySelector('.pdf-container');
                         const targetPage = parent.document.getElementById('page-{st.session_state.scroll_to_page}');
                         
                         if (container && targetPage) {{
-                            // 컨테이너 내에서 타겟 페이지의 위치 계산
                             const containerRect = container.getBoundingClientRect();
                             const targetRect = targetPage.getBoundingClientRect();
                             const scrollTop = container.scrollTop;
                             const offset = targetRect.top - containerRect.top + scrollTop;
                             
-                            // 부드럽게 스크롤
                             container.scrollTo({{
                                 top: offset - 20,
                                 behavior: 'smooth'
@@ -1122,9 +1105,8 @@ def main():
                     st.session_state.scroll_to_page = None
         
         with col2:
-            st.markdown('<h3 class="chat-title">🔮 PLOBIN CHAT</h3>', unsafe_allow_html=True)
+            st.markdown('### PLOBIN CHAT', unsafe_allow_html=True)
             
-            # 채팅 히스토리를 담을 컨테이너
             chat_container = st.container(height=650)
             
             with chat_container:
@@ -1135,12 +1117,10 @@ def main():
                         if msg["role"] == "assistant" and "sources" in msg:
                             with st.expander("📚 참조 문서"):
                                 for idx, (doc, meta) in enumerate(zip(msg["sources"]["docs"], msg["sources"]["metas"])):
-                                    # 텍스트를 150자로 제한하고 간결하게 표시
                                     clean_text = doc[:150] + ('...' if len(doc) > 150 else '')
                                     
-                                    # 페이지 번호 버튼 (박스처럼 보이게) - msg_idx 추가로 고유 키 생성
                                     if st.button(
-                                        f"📄 페이지 {meta['page']}", 
+                                        f"페이지 {meta['page']}", 
                                         key=f"goto_source_msg{msg_idx}_{meta['page']}_{idx}",
                                         use_container_width=True,
                                         type="secondary"
@@ -1148,7 +1128,6 @@ def main():
                                         st.session_state.scroll_to_page = meta['page']
                                         st.rerun()
                                     
-                                    # 문서 내용 표시
                                     st.markdown(f"""
                                     <div style="background: #F1F5F9; padding: 0.8rem; border-radius: 0.5rem; margin-bottom: 1rem; border-left: 3px solid #667eea;">
                                         <div style="font-size: 0.9rem; color: #475569;">
@@ -1156,50 +1135,20 @@ def main():
                                         </div>
                                     </div>
                                     """, unsafe_allow_html=True)
-                            
-                            # Grok 검증 결과 표시 (최종 1개)
-                            if "grok_verified" in msg["sources"]:
-                                with st.expander("🔍 Grok AI 최종 선택"):
-                                    grok_data = msg["sources"]["grok_verified"]
-                                    if isinstance(grok_data, dict) and "selected_text" in grok_data:
-                                        selected_text = grok_data.get('selected_text', '선택된 정보 없음')
-                                        # 텍스트를 150자로 제한
-                                        display_text = selected_text[:150] + ('...' if len(selected_text) > 150 else '')
-                                        
-                                        # 페이지 번호 버튼 (하이라이트 스타일) - msg_idx 추가로 고유 키 생성
-                                        if st.button(
-                                            f"⭐ 페이지 {grok_data.get('page', '?')}", 
-                                            key=f"goto_grok_msg{msg_idx}_{grok_data.get('page', 0)}",
-                                            use_container_width=True,
-                                            type="primary"
-                                        ):
-                                            st.session_state.scroll_to_page = grok_data.get('page', 1)
-                                            st.rerun()
-                                        
-                                        # 선택된 텍스트 표시
-                                        st.markdown(f"""
-                                        <div style="background: #FEF08A; color: #854D0E; padding: 0.8rem; border-radius: 0.5rem; margin-top: 0.5rem; border-left: 4px solid #EAB308;">
-                                            <div style="font-size: 0.9rem;">{display_text}</div>
-                                        </div>
-                                        """, unsafe_allow_html=True)
             
-            # 채팅 입력 - 컨테이너 바로 아래에 배치
             prompt = st.chat_input("💬 질문을 입력하세요...", key="chat_input")
             
-            # 1단계: 질문을 받으면 즉시 히스토리에 추가하고 rerun (질문이 채팅 박스 안에 나타남)
             if prompt:
                 st.session_state.chat_history.append({"role": "user", "content": prompt})
                 st.session_state.processing_query = prompt
                 st.rerun()
             
-            # 2단계: processing_query가 있으면 AI 답변 생성
             if st.session_state.processing_query:
                 query = st.session_state.processing_query
-                st.session_state.processing_query = None  # 플래그 리셋
+                st.session_state.processing_query = None
                 
-                with st.spinner("🔮 PLOBIN이 검색중입니다..."):
+                with st.spinner("PLOBIN이 검색중입니다..."):
                     try:
-                        # 1. 하이브리드 검색 (벡터 + 의미 기반 키워드) - 상위 3개
                         search_results = hybrid_search(
                             query,
                             st.session_state.vector_db,
@@ -1207,29 +1156,24 @@ def main():
                             top_k=3
                         )
                         
-                        # 2. Grok API로 검증 및 추출
                         grok_result = grok_verify_and_extract(
                             query,
                             search_results,
                             GROK_API_KEY
                         )
                         
-                        # 3. 답변 생성
                         answer = generate_answer(
                             query,
                             search_results,
                             GROK_API_KEY
                         )
                         
-                        # 4. Grok 추출 결과를 하이라이트로 변환
-                        highlights = extract_highlights_from_grok(grok_result)
+                        highlights = extract_highlights_from_answer(answer)
                         st.session_state.current_highlights = highlights
                         
-                        # 5. Grok이 선택한 페이지로 자동 스크롤 설정
                         if grok_result and "page" in grok_result and "error" not in grok_result:
                             st.session_state.scroll_to_page = grok_result["page"]
                         
-                        # 6. 채팅 히스토리에 답변 저장
                         chat_data = {
                             "role": "assistant",
                             "content": answer,