add files

.gitignore

@@ -0,0 +1,27 @@
+# API Keys
+.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+ENV/
+env/
+
+# Data
+data/uploads/*.pdf
+data/chroma_db/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+

config/settings.py

@@ -0,0 +1,43 @@
+# config/settings.py
+"""설정 파일"""
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# 브랜딩 (✅ PROBIN)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━
+APP_NAME = "PROBIN"
+APP_SUBTITLE = "Experience Intelligent Document Analysis with AI"
+APP_ICON = "🔮"  # 수정구슬
+
+# UI 설정
+SHOW_STATS = False  # 통계 숨김
+PDF_HEIGHT = "80vh"
+
+# API Keys
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+XAI_API_KEY = os.getenv("XAI_API_KEY")
+
+if not OPENAI_API_KEY or not XAI_API_KEY:
+    raise ValueError("❌ .env 파일에 API Keys를 설정하세요!")
+
+# 임베딩 설정
+EMBEDDING_MODEL = "text-embedding-3-small"
+EMBEDDING_DIMENSION = 1536
+
+# 청킹 설정
+CHUNK_SIZE = 800
+CHUNK_OVERLAP = 150
+
+# 검색 설정
+TOP_K = 10
+
+# ChromaDB 설정
+CHROMA_PATH = "./data/chroma_db"
+COLLECTION_NAME = "rfp_documents"
+
+# Grok 설정
+GROK_MODEL = "grok-3" 
+GROK_BASE_URL = "https://api.x.ai/v1"

core/chunker.py

@@ -0,0 +1,73 @@
+# core/chunker.py
+"""텍스트 청킹"""
+from typing import List, Dict
+from config.settings import CHUNK_SIZE, CHUNK_OVERLAP
+
+
+def chunk_text(pages: List[Dict], chunk_size: int = CHUNK_SIZE, overlap: int = CHUNK_OVERLAP) -> List[Dict]:
+    """
+    텍스트를 청크로 분할
+    
+    Args:
+        pages: 페이지별 텍스트
+        chunk_size: 청크 크기
+        overlap: 오버랩 크기
+    
+    Returns:
+        List[Dict]: 청크 리스트
+            [
+                {
+                    "chunk_id": "chunk_0",
+                    "text": "...",
+                    "page_num": 1,
+                    "start_char": 0,
+                    "end_char": 800
+                },
+                ...
+            ]
+    """
+    print(f"✂️  청킹 시작 (크기: {chunk_size}, 오버랩: {overlap})")
+    
+    chunks = []
+    chunk_id = 0
+    
+    for page in pages:
+        page_num = page["page_num"]
+        text = page["text"]
+        
+        # 페이지 텍스트를 청크로 분할
+        start = 0
+        while start < len(text):
+            end = start + chunk_size
+            chunk_text = text[start:end]
+            
+            # 빈 청크 제외
+            if chunk_text.strip():
+                chunks.append({
+                    "chunk_id": f"chunk_{chunk_id}",
+                    "text": chunk_text,
+                    "page_num": page_num,
+                    "start_char": start,
+                    "end_char": end
+                })
+                chunk_id += 1
+            
+            # 다음 청크 시작 위치 (오버랩 고려)
+            start += (chunk_size - overlap)
+    
+    print(f"✅ {len(chunks)}개 청크 생성")
+    
+    return chunks
+
+
+if __name__ == "__main__":
+    # 테스트
+    test_pages = [
+        {"page_num": 1, "text": "테스트 " * 500},
+        {"page_num": 2, "text": "문서 " * 500}
+    ]
+    
+    chunks = chunk_text(test_pages)
+    print(f"생성된 청크 수: {len(chunks)}")
+    print(f"첫 청크: {chunks[0]}")
+

core/embedder.py

@@ -0,0 +1,60 @@
+# core/embedder.py
+"""임베딩 생성"""
+from openai import OpenAI
+from typing import List, Dict
+from config.settings import OPENAI_API_KEY, EMBEDDING_MODEL
+import time
+
+client = OpenAI(api_key=OPENAI_API_KEY)
+
+
+def embed_chunks(chunks: List[Dict]) -> List[Dict]:
+    """
+    청크 리스트를 임베딩
+    
+    Args:
+        chunks: 청크 리스트
+    
+    Returns:
+        List[Dict]: 임베딩이 추가된 청크
+            [
+                {
+                    "chunk_id": "...",
+                    "text": "...",
+                    "embedding": [0.1, 0.2, ...],
+                    ...
+                },
+                ...
+            ]
+    """
+    print(f"🔢 임베딩 시작 ({len(chunks)}개 청크)")
+    start_time = time.time()
+    
+    # 배치 처리 (OpenAI는 한 번에 여러 개 가능)
+    texts = [chunk["text"] for chunk in chunks]
+    
+    response = client.embeddings.create(
+        model=EMBEDDING_MODEL,
+        input=texts
+    )
+    
+    # 임베딩 추가
+    for i, chunk in enumerate(chunks):
+        chunk["embedding"] = response.data[i].embedding
+    
+    elapsed = time.time() - start_time
+    print(f"✅ 임베딩 완료 ({elapsed:.2f}초)")
+    print(f"   - 속도: {len(chunks)/elapsed:.2f} chunks/sec")
+    
+    return chunks
+
+
+if __name__ == "__main__":
+    # 테스트
+    test_chunks = [
+        {"chunk_id": "chunk_0", "text": "테스트 문서입니다."}
+    ]
+    
+    embedded = embed_chunks(test_chunks)
+    print(f"임베딩 차원: {len(embedded[0]['embedding'])}")
+

core/generator.py

@@ -0,0 +1,193 @@
+# core/generator.py
+"""Grok 답변 생성"""
+from openai import OpenAI
+from typing import List, Dict
+from config.settings import XAI_API_KEY, GROK_MODEL, GROK_BASE_URL
+
+# Grok 클라이언트 초기화
+client = OpenAI(
+    api_key=XAI_API_KEY,
+    base_url=GROK_BASE_URL
+)
+
+
+class Generator:
+    """답변 생성 클래스"""
+    
+    def __init__(self):
+        """생성기 초기화"""
+        pass
+    
+    def generate_answer(self, query: str, retrieved_chunks: List[Dict]) -> Dict:
+        """
+        검색된 청크를 바탕으로 답변 생성
+        
+        Args:
+            query: 사용자 질문
+            retrieved_chunks: 검색된 청크 리스트
+        
+        Returns:
+            Dict: {
+                "answer": "답변 텍스트",
+                "sources": [
+                    {"page_num": 1, "text": "...", "chunk_id": "..."},
+                    ...
+                ]
+            }
+        """
+        print(f"🤖 Grok 답변 생성 중...")
+        
+        # 컨텍스트 구성
+        context = self._build_context(retrieved_chunks)
+        
+        # 프롬프트 구성
+        prompt = self._build_prompt(query, context)
+        
+        # Grok 호출
+        response = client.chat.completions.create(
+            model=GROK_MODEL,
+            messages=[
+                {
+                    "role": "system",
+                    "content": """당신은 RFP(제안요청서) 문서 분석 전문가입니다.
+제공된 문서 내용만을 기반으로 정확하고 구체적으로 답변하세요.
+문서에 없는 내용은 추측하지 말고 솔직히 "문서에서 해당 정보를 찾을 수 없습니다"라고 답변하세요.
+답변 시 반드시 출처 페이지 번호를 [페이지 X] 형식으로 명시하세요."""
+                },
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ],
+            temperature=0.3,
+            max_tokens=1000
+        )
+        
+        answer = response.choices[0].message.content
+        
+        # 답변에서 페이지 번호 추출 (예: [페이지 7])
+        import re
+        page_matches = re.findall(r'\[페이지\s*(\d+)\]', answer)
+        mentioned_page = int(page_matches[0]) if page_matches else None
+        
+        # 소스 정리 (답변에 언급된 페이지 우선)
+        sources = self._extract_sources(retrieved_chunks, mentioned_page)
+        
+        print(f"✅ 답변 생성 완료 ({len(answer)}자)")
+        if mentioned_page:
+            print(f"   📍 답변 출처: 페이지 {mentioned_page}")
+        
+        return {
+            "answer": answer,
+            "sources": sources
+        }
+    
+    def _build_context(self, chunks: List[Dict]) -> str:
+        """
+        청크를 컨텍스트 문자열로 변환
+        
+        Args:
+            chunks: 청크 리스트
+        
+        Returns:
+            str: 컨텍스트 문자열
+        """
+        context_parts = []
+        for i, chunk in enumerate(chunks, 1):
+            context_parts.append(
+                f"[문서 {i} - 페이지 {chunk['page_num']}]\n{chunk['text']}\n"
+            )
+        
+        return "\n".join(context_parts)
+    
+    def _build_prompt(self, query: str, context: str) -> str:
+        """
+        프롬프트 구성 (하이라이트용 인용문 포함)
+        
+        Args:
+            query: 사용자 질문
+            context: 컨텍스트
+        
+        Returns:
+            str: 프롬프트
+        """
+        prompt = f"""당신은 RFP(제안요청서) 문서 분석 전문가입니다.
+다음 문서 내용을 바탕으로 질문에 답변하세요.
+
+# 문서 내용
+{context}
+
+# 질문
+{query}
+
+# 답변 규칙
+1. 반드시 제공된 문서 내용만을 기반으로 답변하세요
+2. 문서에 없는 내용이면 "제공된 문서에서 해당 정보를 찾을 수 없습니다"라고 답변하세요
+3. 답변 시 출처 페이지 번호를 [페이지 X] 형식으로 명시하세요
+4. **중요**: 답변의 핵심 근거가 되는 문서의 원문을 그대로 인용하세요
+   - 답변 끝에 "---핵심 인용---" 다음에 PDF에서 하일라이트할 정확한 문장을 적어주세요
+   - 인용문은 문서 원문 그대로, 10-30단어 정도로 적어주세요
+5. 명확하고 간결하게 답변하세요
+
+# 답변 형식 예시
+(답변 내용)... [페이지 7]
+
+---핵심 인용---
+차체 및 일반부품의 보증기간: 3년/6만km 이내
+"""
+        
+        return prompt
+    
+    def _extract_sources(self, chunks: List[Dict], mentioned_page: int = None) -> List[Dict]:
+        """
+        소스 정보 추출 (답변에 언급된 페이지 우선)
+        
+        Args:
+            chunks: 청크 리스트 (이미 관련도 순으로 정렬됨)
+            mentioned_page: AI 답변에 언급된 페이지 번호
+        
+        Returns:
+            List[Dict]: 소스 정보 (mentioned_page가 있��면 해당 페이지 청크를 1위로)
+        """
+        # mentioned_page가 있으면 해당 페이지 청크를 최우선으로
+        if mentioned_page:
+            # 해당 페이지의 청크를 찾아서 맨 앞으로
+            reordered_chunks = []
+            mentioned_chunks = [c for c in chunks if c["page_num"] == mentioned_page]
+            other_chunks = [c for c in chunks if c["page_num"] != mentioned_page]
+            
+            reordered_chunks = mentioned_chunks + other_chunks
+            chunks = reordered_chunks
+        
+        sources = []
+        seen_pages = set()
+        
+        for chunk in chunks[:5]:  # 상위 5개만
+            page_num = chunk["page_num"]
+            if page_num not in seen_pages:
+                sources.append({
+                    "page_num": page_num,
+                    "text": chunk["text"][:200] + "...",  # 미리보기
+                    "chunk_id": chunk["chunk_id"]
+                })
+                seen_pages.add(page_num)
+        
+        return sources
+
+
+if __name__ == "__main__":
+    # 테스트
+    generator = Generator()
+    
+    test_chunks = [
+        {
+            "chunk_id": "chunk_0",
+            "text": "이 프로젝트의 예산은 1억원입니다.",
+            "page_num": 1
+        }
+    ]
+    
+    result = generator.generate_answer("예산이 얼마인가요?", test_chunks)
+    print(f"답변: {result['answer']}")
+    print(f"출처: {len(result['sources'])}개")
+

core/pdf_loader.py

@@ -0,0 +1,58 @@
+# core/pdf_loader.py
+"""PDF 텍스트 추출"""
+import pymupdf4llm
+import fitz  # PyMuPDF
+from typing import Dict, List
+
+
+def load_pdf(pdf_path: str) -> Dict:
+    """
+    PDF 파일 로드 및 텍스트 추출
+    
+    Args:
+        pdf_path: PDF 파일 경로
+    
+    Returns:
+        Dict: {
+            "text": "전체 텍스트",
+            "pages": [
+                {"page_num": 1, "text": "..."},
+                ...
+            ]
+        }
+    """
+    print(f"📄 PDF 로드 중: {pdf_path}")
+    
+    # pymupdf4llm으로 텍스트 추출 (markdown 형식)
+    md_text = pymupdf4llm.to_markdown(pdf_path)
+    
+    # 페이지별로 분리
+    doc = fitz.open(pdf_path)
+    
+    pages = []
+    for page_num, page in enumerate(doc, start=1):
+        page_text = page.get_text()
+        pages.append({
+            "page_num": page_num,
+            "text": page_text
+        })
+    
+    doc.close()
+    
+    print(f"✅ {len(pages)}페이지 추출 완료")
+    
+    return {
+        "text": md_text,
+        "pages": pages,
+        "total_pages": len(pages)
+    }
+
+
+if __name__ == "__main__":
+    # 테스트
+    import sys
+    if len(sys.argv) > 1:
+        result = load_pdf(sys.argv[1])
+        print(f"총 페이지: {result['total_pages']}")
+        print(f"첫 페이지 미리보기: {result['pages'][0]['text'][:200]}")
+

core/retriever.py

@@ -0,0 +1,67 @@
+# core/retriever.py
+"""검색 로직 - 관련도 점수 포함"""
+from openai import OpenAI
+from typing import List, Dict
+from config.settings import OPENAI_API_KEY, EMBEDDING_MODEL, TOP_K
+
+client = OpenAI(api_key=OPENAI_API_KEY)
+
+
+class Retriever:
+    """RAG 검색 클래스 (1D 전용 버전)"""
+
+    def __init__(self, vectordb):
+        self.vectordb = vectordb
+
+    def retrieve(self, query: str, top_k: int = TOP_K) -> List[Dict]:
+        """
+        질문(query)에 가장 유사한 청크를 벡터DB에서 검색하여
+        관련도 점수(relevance_score)까지 계산한 후 반환.
+        
+        **중요**: distance가 작을수록 관련도가 높음 → 오름차순 정렬
+        """
+        print(f"🔍 검색 중: '{query[:50]}...'")
+
+        # --- 1. 질문 임베딩 생성 ---
+        embedding_response = client.embeddings.create(
+            model=EMBEDDING_MODEL,
+            input=[query]
+        )
+        query_embedding = embedding_response.data[0].embedding
+
+        # --- 2. 벡터 검색 (1D 구조) ---
+        results = self.vectordb.search(query_embedding, top_k)
+
+        ids = results["ids"]
+        docs = results["documents"]
+        metas = results["metadatas"]
+        dists = results["distances"]
+
+        chunks = []
+
+        # --- 3. 포맷팅 + 관련도 점수 계산 ---
+        for i in range(len(ids)):
+            distance = dists[i] if i < len(dists) else 1.0
+            relevance_score = round(1.0 - distance, 4)
+
+            meta = metas[i] if isinstance(metas[i], dict) else {}
+
+            chunks.append({
+                "chunk_id": ids[i],
+                "text": docs[i],
+                "page_num": meta.get("page_num", 0),
+                "start_char": meta.get("start_char", 0),
+                "end_char": meta.get("end_char", 0),
+                "distance": distance,
+                "relevance_score": relevance_score
+            })
+        
+        # --- 4. ✅ distance 오름차순 정렬 (작을수록 관련도 높음) ---
+        chunks.sort(key=lambda x: x["distance"])
+        
+        # 디버그: 상위 3개 출력
+        print(f"✅ {len(chunks)}개 청크 검색 완료")
+        if chunks:
+            print(f"   🎯 최고 관련도: p.{chunks[0]['page_num']} (distance: {chunks[0]['distance']:.4f})")
+
+        return chunks

core/vectordb.py

@@ -0,0 +1,100 @@
+# core/vectordb.py
+"""ChromaDB 관리 (프로덕션 버전)"""
+import chromadb
+import uuid
+from pathlib import Path
+from typing import List, Dict
+from config.settings import CHROMA_PATH
+
+
+class VectorDB:
+    """ChromaDB 관리 클래스 (프로덕션 안정화)"""
+    
+    def __init__(self, persist_directory: str = CHROMA_PATH, session_id: str = None):
+        """
+        ChromaDB 초기화 (세션별 컬렉션)
+        
+        Args:
+            persist_directory: 저장 경로
+            session_id: 세션 ID (없으면 자동 생성)
+        """
+        print(f"🗄️  ChromaDB 초기화 중...")
+        
+        self.persist_directory = persist_directory
+        
+        # 세션 ID 기반 컬렉션 이름
+        if session_id is None:
+            session_id = str(uuid.uuid4())[:8]
+        
+        self.collection_name = f"session_{session_id}"
+        print(f"   📛 컬렉션 이름: {self.collection_name}")
+        
+        # PersistentClient 생성
+        self.client = chromadb.PersistentClient(path=persist_directory)
+        
+        # ✅ get_or_create 사용 (프로덕션 표준)
+        self.collection = self.client.get_or_create_collection(
+            name=self.collection_name,
+            metadata={"description": "RFP 문서 임베딩"}
+        )
+        
+        print(f"✅ ChromaDB 준비 완료 (현재 {self.collection.count()}개 청크)")
+    
+    def add_chunks(self, chunks: List[Dict]):
+        """청크 저장"""
+        print(f"💾 {len(chunks)}개 청크 저장 중...")
+        
+        ids = [chunk["chunk_id"] for chunk in chunks]
+        embeddings = [chunk["embedding"] for chunk in chunks]
+        documents = [chunk["text"] for chunk in chunks]
+        
+        metadatas = []
+        for chunk in chunks:
+            metadatas.append({
+                "page_num": chunk.get("page_num", 0),
+                "start_char": chunk.get("start_char", 0),
+                "end_char": chunk.get("end_char", 0)
+            })
+        
+        self.collection.add(
+            ids=ids,
+            embeddings=embeddings,
+            documents=documents,
+            metadatas=metadatas
+        )
+        
+        print("✅ 저장 완료")
+    
+    def search(self, query_embedding: List[float], top_k: int = 10) -> Dict:
+        """벡터 검색"""
+        results = self.collection.query(
+            query_embeddings=[query_embedding],
+            n_results=top_k
+        )
+        
+        return {
+            "ids": results["ids"][0],
+            "documents": results["documents"][0],
+            "metadatas": results["metadatas"][0],
+            "distances": results["distances"][0]
+        }
+    
+    def delete_collection(self):
+        """현재 컬렉션 삭제"""
+        print(f"🗑️  컬렉션 삭제 중: {self.collection_name}")
+        try:
+            self.client.delete_collection(name=self.collection_name)
+            print("   ✅ 삭제 완료")
+        except Exception as e:
+            print(f"   ⚠️ 삭제 오류: {e}")
+    
+    def count(self) -> int:
+        """현재 청크 개수"""
+        return self.collection.count()
+    
+    def get_stats(self) -> Dict:
+        """통계"""
+        return {
+            "total_chunks": self.collection.count(),
+            "collection_name": self.collection_name
+        }

ui/components.py

@@ -0,0 +1,210 @@
+# ui/components.py
+"""PROBIN UI 컴포넌트"""
+import streamlit as st
+from typing import List, Dict
+
+
+def render_header():
+    """헤더 렌더링 (PROBIN 버전)"""
+    st.markdown(
+        """
+        <div style="text-align: center; padding: 2rem 0;">
+            <h1 style="color: #2196F3; font-size: 3rem;">🧠 PROBIN</h1>
+            <p style="font-size: 1.2rem; color: #666;">Intelligent Document Analysis System</p>
+            <p style="font-size: 0.9rem; color: #999;">정확도 우선 RAG 시스템</p>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
+
+def render_sources_with_relevance(sources: List[Dict], message_idx: int, move_to_page_callback):
+    """
+    출처 렌더링 (가장 관련도 높은 것 우선)
+    
+    Args:
+        sources: 출처 리스트 (이미 관련도 순으로 정렬됨)
+        message_idx: 메시지 인덱스 (키 중복 방지용)
+        move_to_page_callback: 페이지 이동 콜백 함수
+    
+    구조:
+        🎯 핵심 근거 (1개) - sources[0]: 가장 관련도 높은 출처
+        📚 추가 참고 문서 (나머지) - Expander 내부
+    """
+    if not sources:
+        return
+    
+    # 첫 번째 출처 = 가장 관련도 높음
+    st.markdown("---")
+    st.markdown("**🎯 핵심 근거:**")
+    
+    primary_source = sources[0]
+    
+    if st.button(
+        f"📍 페이지 {primary_source['page_num']} 확인",
+        key=f"primary_{message_idx}",
+        type="primary",
+        use_container_width=True
+    ):
+        move_to_page_callback(primary_source['page_num'], primary_source['text'])
+    
+    # 미리보기
+    st.caption(f"💬 \"{primary_source['text'][:100]}...\"")
+    
+    # 추가 참고 문서 (나머지)
+    if len(sources) > 1:
+        additional_sources = sources[1:]
+        
+        with st.expander(f"📚 추가 참고 문서 ({min(2, len(additional_sources))}개)"):
+            cols = st.columns(2)
+            
+            for i, src in enumerate(additional_sources[:2]):  # 최대 2개만
+                with cols[i]:
+                    if st.button(
+                        f"p.{src['page_num']}",
+                        key=f"additional_{message_idx}_{i}",
+                        use_container_width=True
+                    ):
+                        move_to_page_callback(src['page_num'], src['text'])
+                    
+                    st.caption(f"\"{src['text'][:60]}...\"")
+
+
+
+def render_answer(answer: str, sources: List[Dict]):
+    """답변 및 출처 렌더링 (Legacy - 사용 안 함)"""
+    # 답변
+    st.markdown("### 💡 답변")
+    st.markdown(
+        f"""
+        <div class="answer-box">
+            {answer}
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+    
+    # 출처
+    if sources:
+        st.markdown("### 📄 출처")
+        for i, source in enumerate(sources, 1):
+            with st.expander(f"출처 {i} - 페이지 {source['page_num']}"):
+                st.text(source['text'])
+
+
+def render_file_uploader():
+    """파일 업로더 렌더링"""
+    st.markdown("### 📤 PDF 업로드")
+    
+    uploaded_file = st.file_uploader(
+        "RFP PDF 파일을 업로드하세요",
+        type=["pdf"],
+        help="PDF 형식의 RFP 문서를 업로드하세요"
+    )
+    
+    return uploaded_file
+
+
+def render_query_input():
+    """질문 입력 렌더링 (Deprecated: st.chat_input 사용 권장)"""
+    st.markdown("### 💬 질문하기")
+    
+    query = st.text_input(
+        "질문을 입력하세요",
+        placeholder="예: 이 프로젝트의 예산은 얼마인가요?",
+        help="RFP 문서에 대해 질문하세요"
+    )
+    
+    return query
+
+
+def render_chat_history(messages: list):
+    """채팅 히스토리 렌더링 (현대적 방식)"""
+    for message in messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+            
+            # 출처 표시
+            if message["role"] == "assistant" and "sources" in message:
+                with st.expander("📚 출처 보기"):
+                    for i, src in enumerate(message["sources"], 1):
+                        st.markdown(f"**출처 {i} - [페이지 {src['page_num']}]**")
+                        st.caption(src["text"])
+
+
+def render_sidebar():
+    """사이드바 렌더링"""
+    with st.sidebar:
+        st.markdown("## ⚙️ 설정")
+        
+        # 검색 설정
+        st.markdown("### 🔍 검색 설정")
+        top_k = st.slider("검색할 청크 수", 5, 20, 10)
+        
+        # 청킹 설정
+        st.markdown("### ✂️ 청킹 설정")
+        chunk_size = st.number_input("청크 크기", 400, 1200, 800, step=100)
+        chunk_overlap = st.number_input("오버랩 크기", 50, 300, 150, step=50)
+        
+        st.markdown("---")
+        
+        # 정보
+        st.markdown("### ℹ️ 정보")
+        st.info(
+            """
+            **PROBIN v2.0**
+            
+            - PDF 업로드 ✅
+            - 질문-답변 ✅
+            - 출처 표시 ✅
+            - 벡터 검색 ✅
+            - 하이라이트 ✅
+            """
+        )
+        
+        # 초기화 버튼
+        if st.button("🗑️ 데이터베이스 초기화", type="secondary"):
+            return True, top_k, chunk_size, chunk_overlap
+        
+        return False, top_k, chunk_size, chunk_overlap
+
+
+def render_processing_status(status: str):
+    """처리 상태 렌더링"""
+    status_icons = {
+        "uploading": "📤",
+        "extracting": "📄",
+        "chunking": "✂️",
+        "embedding": "🔢",
+        "storing": "💾",
+        "complete": "✅"
+    }
+    
+    icon = status_icons.get(status, "⏳")
+    st.info(f"{icon} {status}")
+
+
+def render_welcome_message():
+    """웰컴 메시지 (사용 안내)"""
+    st.markdown("""
+    <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 12px; margin-bottom: 20px; text-align: center;">
+        <h2 style="margin: 0 0 10px 0;">🧠 PROBIN에 오신 것을 환영합니다!</h2>
+        <p style="margin: 0; opacity: 0.9;">Intelligent Document Analysis System</p>
+    </div>
+    
+    <div style="background-color: #f0f7ff; border-left: 4px solid #2196F3; padding: 15px; border-radius: 8px; margin-bottom: 15px;">
+        <h4 style="margin-top: 0; color: #1976D2;">📖 이용 방법</h4>
+        <ol style="line-height: 1.8; margin: 0;">
+            <li><strong>PDF 업로드:</strong> 왼쪽 사이드바에서 문서를 업로드하세요</li>
+            <li><strong>문서 처리:</strong> 30초~1분 정도 기다립니다</li>
+            <li><strong>질문 입력:</strong> 채팅창에 질문을 입력하세요</li>
+            <li><strong>근거 확인:</strong> <span style="background-color: rgba(255,255,0,0.5); padding: 2px 6px; border-radius: 3px;">노란색 하이라이트</span>로 근거를 확인하세요</li>
+        </ol>
+    </div>
+    
+    <div style="text-align: center; margin-top: 20px;">
+        <span style="display: inline-block; margin: 5px; padding: 8px 16px; background-color: #e8f5e9; border-radius: 20px; font-size: 0.9rem;">📺 Split View</span>
+        <span style="display: inline-block; margin: 5px; padding: 8px 16px; background-color: #fff3e0; border-radius: 20px; font-size: 0.9rem;">🖍️ Highlighting</span>
+        <span style="display: inline-block; margin: 5px; padding: 8px 16px; background-color: #f3e5f5; border-radius: 20px; font-size: 0.9rem;">🎯 High Accuracy</span>
+    </div>
+    """, unsafe_allow_html=True)

ui/styles.py

@@ -0,0 +1,509 @@
+# ui/styles.py
+"""UI 스타일 정의 - Claude 스타일 다크 배경"""
+
+def get_custom_css():
+    """커스텀 CSS 반환"""
+    return """
+    <style>
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       🌊 애니메이션 배경 (Pure CSS)
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    .animated-background {
+        position: fixed;
+        width: 100%;
+        height: 100%;
+        top: 0;
+        left: 0;
+        z-index: -1;
+        background: linear-gradient(
+            45deg,
+            #667eea 0%,
+            #764ba2 25%,
+            #f093fb 50%,
+            #4facfe 75%,
+            #667eea 100%
+        );
+        background-size: 400% 400%;
+        animation: gradientFlow 15s ease infinite;
+    }
+    
+    /* 배경 위에 떠다니는 원들 */
+    .animated-background::before,
+    .animated-background::after {
+        content: '';
+        position: absolute;
+        border-radius: 50%;
+        filter: blur(80px);
+        opacity: 0.2;
+        animation: float 25s ease-in-out infinite;
+    }
+    
+    .animated-background::before {
+        width: 600px;
+        height: 600px;
+        background: radial-gradient(circle, rgba(255,255,255,0.2), transparent);
+        top: 10%;
+        left: 20%;
+        animation-delay: 0s;
+    }
+    
+    .animated-background::after {
+        width: 500px;
+        height: 500px;
+        background: radial-gradient(circle, rgba(255,255,255,0.15), transparent);
+        bottom: 15%;
+        right: 10%;
+        animation-delay: 7s;
+    }
+    
+    @keyframes gradientFlow {
+        0% { background-position: 0% 50%; }
+        50% { background-position: 100% 50%; }
+        100% { background-position: 0% 50%; }
+    }
+    
+    @keyframes float {
+        0%, 100% { transform: translate(0, 0) scale(1); }
+        25% { transform: translate(40px, -40px) scale(1.1); }
+        50% { transform: translate(-30px, 30px) scale(0.9); }
+        75% { transform: translate(50px, 15px) scale(1.05); }
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       🏠 Hero Container (초기 화면)
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    .hero-container {
+        position: relative;
+        text-align: center;
+        padding: 10rem 2rem;
+        min-height: 80vh;
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+        background: transparent;
+        z-index: 1;
+    }
+    
+    .hero-title {
+        font-size: 5rem;
+        font-weight: 900;
+        color: white;
+        margin-bottom: 1.5rem;
+        text-shadow: 
+            0 0 30px rgba(255,255,255,0.6),
+            0 0 50px rgba(102,126,234,0.4),
+            3px 3px 40px rgba(0,0,0,0.4);
+        animation: titlePulse 4s ease-in-out infinite;
+        letter-spacing: 4px;
+    }
+    
+    @keyframes titlePulse {
+        0%, 100% {
+            transform: scale(1);
+            text-shadow: 
+                0 0 30px rgba(255,255,255,0.6),
+                0 0 50px rgba(102,126,234,0.4);
+        }
+        50% {
+            transform: scale(1.03);
+            text-shadow: 
+                0 0 40px rgba(255,255,255,0.8),
+                0 0 70px rgba(102,126,234,0.6),
+                0 0 100px rgba(118,75,162,0.4);
+        }
+    }
+    
+    .hero-subtitle {
+        font-size: 1.9rem;
+        color: rgba(255,255,255,0.95);
+        font-weight: 300;
+        letter-spacing: 4px;
+        text-shadow: 
+            0 0 15px rgba(255,255,255,0.4),
+            2px 2px 25px rgba(0,0,0,0.3);
+        animation: subtitleFade 2.5s ease-out;
+    }
+    
+    @keyframes subtitleFade {
+        from {
+            opacity: 0;
+            transform: translateY(30px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+    
+    /* 모바일 반응형 */
+    @media (max-width: 768px) {
+        .hero-title {
+            font-size: 2.5rem;
+            letter-spacing: 2px;
+        }
+        .hero-subtitle {
+            font-size: 1.1rem;
+            letter-spacing: 2px;
+        }
+        .hero-container {
+            padding: 5rem 1rem;
+        }
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       💬 Chat Placeholder (가이드 화면) - 다크 모드
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    .chat-placeholder {
+        background: linear-gradient(135deg, 
+            rgba(30,30,35,0.95) 0%, 
+            rgba(25,25,30,0.95) 100%);
+        border-radius: 20px;
+        padding: 3rem;
+        text-align: left;
+        box-shadow: 
+            0 15px 50px rgba(0,0,0,0.4),
+            0 0 0 1px rgba(102,126,234,0.2) inset;
+        animation: slideIn 0.7s ease-out;
+        backdrop-filter: blur(15px);
+        border: 1px solid rgba(102,126,234,0.2);
+    }
+    
+    @keyframes slideIn {
+        from {
+            opacity: 0;
+            transform: translateY(40px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+    
+    .placeholder-title {
+        font-size: 2rem;
+        font-weight: 900;
+        background: linear-gradient(135deg, #667eea, #f093fb);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+        margin-bottom: 2.5rem;
+        text-align: center;
+    }
+    
+    .placeholder-steps {
+        margin: 2.5rem 0;
+        padding-left: 0;
+        line-height: 2.5;
+        color: rgba(255,255,255,0.9);
+        font-size: 1.1rem;
+        list-style: none;
+    }
+    
+    .placeholder-steps li {
+        margin-bottom: 1.5rem;
+        padding-left: 3rem;
+        position: relative;
+    }
+    
+    .placeholder-steps li::before {
+        content: '✓';
+        position: absolute;
+        left: 0;
+        top: 0;
+        width: 35px;
+        height: 35px;
+        background: linear-gradient(135deg, #667eea, #764ba2);
+        color: white;
+        border-radius: 50%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-weight: bold;
+        font-size: 1.3rem;
+        box-shadow: 0 4px 15px rgba(102,126,234,0.4);
+    }
+    
+    .placeholder-steps strong {
+        color: #7c92ff;
+        font-weight: 800;
+    }
+    
+    .highlight-box {
+        background: linear-gradient(135deg, 
+            rgba(255, 215, 0, 0.4), 
+            rgba(255, 193, 7, 0.4));
+        padding: 4px 12px;
+        border-radius: 6px;
+        font-weight: 800;
+        color: #fff;
+        box-shadow: 0 2px 10px rgba(255, 215, 0, 0.3);
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       🔄 로딩 메시지
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    .loading-message {
+        background: linear-gradient(135deg, 
+            rgba(30,30,35,0.95) 0%, 
+            rgba(25,25,30,0.95) 100%);
+        border-radius: 20px;
+        padding: 2rem;
+        text-align: center;
+        box-shadow: 
+            0 10px 40px rgba(0,0,0,0.4),
+            0 0 0 1px rgba(102,126,234,0.2) inset;
+        animation: pulse 2s ease-in-out infinite;
+        backdrop-filter: blur(15px);
+        border: 1px solid rgba(102,126,234,0.2);
+    }
+    
+    @keyframes pulse {
+        0%, 100% {
+            opacity: 1;
+            transform: scale(1);
+        }
+        50% {
+            opacity: 0.8;
+            transform: scale(1.02);
+        }
+    }
+    
+    .loading-message-text {
+        font-size: 1.3rem;
+        font-weight: 600;
+        background: linear-gradient(135deg, #667eea, #f093fb);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+        margin-bottom: 1rem;
+    }
+    
+    .loading-dots {
+        display: inline-block;
+        animation: dots 1.5s steps(4, end) infinite;
+    }
+    
+    @keyframes dots {
+        0%, 20% { content: '.'; }
+        40% { content: '..'; }
+        60%, 100% { content: '...'; }
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       📚 출처 버튼 스타일
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    .stButton button {
+        transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+        border-radius: 10px;
+    }
+    
+    .stButton button:hover {
+        transform: translateY(-3px);
+        box-shadow: 0 6px 20px rgba(0,0,0,0.2);
+    }
+    
+    .stButton button:active {
+        transform: translateY(-1px);
+        box-shadow: 0 3px 10px rgba(0,0,0,0.15);
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       🎨 사이드바 스타일
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    [data-testid="stSidebar"] {
+        background: linear-gradient(180deg, 
+            #667eea 0%, 
+            #764ba2 100%);
+        box-shadow: 4px 0 30px rgba(0,0,0,0.2);
+    }
+    
+    [data-testid="stSidebar"] h1 {
+        color: white !important;
+        text-shadow: 2px 2px 15px rgba(0,0,0,0.4);
+    }
+    
+    [data-testid="stSidebar"] .stButton button {
+        background: rgba(255,255,255,0.2);
+        color: white;
+        border: 2px solid rgba(255,255,255,0.3);
+        font-weight: 700;
+        backdrop-filter: blur(10px);
+    }
+    
+    [data-testid="stSidebar"] .stButton button:hover {
+        background: rgba(255,255,255,0.3);
+        border-color: rgba(255,255,255,0.5);
+        transform: translateY(-2px);
+    }
+    
+    /* 파일 업로더 스타일 */
+    [data-testid="stSidebar"] [data-testid="stFileUploader"] {
+        background: rgba(255,255,255,0.15);
+        border-radius: 15px;
+        padding: 1.5rem;
+        border: 3px dashed rgba(255,255,255,0.4);
+        transition: all 0.3s ease;
+        backdrop-filter: blur(10px);
+    }
+    
+    [data-testid="stSidebar"] [data-testid="stFileUploader"]:hover {
+        background: rgba(255,255,255,0.25);
+        border-color: rgba(255,255,255,0.6);
+        transform: scale(1.02);
+    }
+    
+    [data-testid="stSidebar"] [data-testid="stFileUploader"] label {
+        color: white !important;
+        font-weight: 600;
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       📄 PDF 하이라이트 (매우 진한 골드)
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    .highlight-text {
+        background: linear-gradient(135deg, 
+            rgba(255, 193, 7, 0.95), 
+            rgba(255, 152, 0, 0.95)) !important;
+        padding: 4px 8px;
+        border-radius: 5px;
+        font-weight: 800;
+        color: #1a1a1a !important;
+        box-shadow: 
+            0 0 15px rgba(255, 193, 7, 0.7),
+            0 3px 8px rgba(0,0,0,0.3);
+        animation: highlightPulse 2.5s ease-in-out infinite;
+    }
+    
+    @keyframes highlightPulse {
+        0%, 100% {
+            box-shadow: 
+                0 0 15px rgba(255, 193, 7, 0.7),
+                0 3px 8px rgba(0,0,0,0.3);
+        }
+        50% {
+            box-shadow: 
+                0 0 25px rgba(255, 193, 7, 0.9),
+                0 5px 15px rgba(0,0,0,0.4);
+        }
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       💬 채팅 메시지 스타일 - 다크 모드
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    [data-testid="stChatMessage"] {
+        border-radius: 15px;
+        padding: 1.5rem;
+        margin-bottom: 1.2rem;
+        animation: messageSlide 0.4s ease-out;
+        background: rgba(30,30,35,0.6) !important;
+        border: 1px solid rgba(102,126,234,0.15);
+    }
+    
+    @keyframes messageSlide {
+        from {
+            opacity: 0;
+            transform: translateX(-30px);
+        }
+        to {
+            opacity: 1;
+            transform: translateX(0);
+        }
+    }
+    
+    /* 사용자 메시지 */
+    [data-testid="stChatMessage"][data-testid*="user"] {
+        background: rgba(102,126,234,0.15) !important;
+    }
+    
+    /* AI 메시지 */
+    [data-testid="stChatMessage"][data-testid*="assistant"] {
+        background: rgba(30,30,35,0.8) !important;
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       🔄 스크롤바 스타일
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    ::-webkit-scrollbar {
+        width: 12px;
+        height: 12px;
+    }
+    
+    ::-webkit-scrollbar-track {
+        background: rgba(0,0,0,0.2);
+        border-radius: 10px;
+    }
+    
+    ::-webkit-scrollbar-thumb {
+        background: linear-gradient(135deg, #667eea, #764ba2);
+        border-radius: 10px;
+        border: 2px solid rgba(0,0,0,0.2);
+    }
+    
+    ::-webkit-scrollbar-thumb:hover {
+        background: linear-gradient(135deg, #764ba2, #f093fb);
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       🎯 로딩 스피너 커스텀
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    .stSpinner > div {
+        border-top-color: #667eea !important;
+        border-right-color: #764ba2 !important;
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       ✨ 메인 컨텐츠 영역 - 다크 배경
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    .main .block-container {
+        padding-top: 1rem !important;
+        padding-bottom: 1rem !important;
+        background: transparent;
+        max-width: 100% !important;
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       🎯 Streamlit 기본 컨테이너 테두리 제거
+       ━━━━━━━━━━��━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    [data-testid="stVerticalBlock"],
+    [data-testid="stHorizontalBlock"],
+    [data-testid="column"] {
+        border: none !important;
+        box-shadow: none !important;
+        background: transparent !important;
+        padding: 0 !important;
+    }
+    
+    /* PDF 뷰어 - 깔끔한 디자인 */
+    [data-testid="stVerticalBlock"] iframe {
+        border-radius: 12px !important;
+        box-shadow: 0 8px 30px rgba(0,0,0,0.3) !important;
+        border: 1px solid rgba(102,126,234,0.2) !important;
+    }
+    
+    /* 채팅 영역 - 테두리 없이 깔끔하게 */
+    [data-testid="column"]:last-child {
+        background: transparent !important;
+        border: none !important;
+        padding: 0.5rem !important;
+    }
+    
+    /* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       📁 파일 업로더 버튼 텍스트 변경
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    [data-testid="stFileUploader"] button[kind="secondary"] {
+        font-size: 0 !important;
+    }
+    
+    [data-testid="stFileUploader"] button[kind="secondary"]::after {
+        content: "파일 찾기";
+        font-size: 1rem;
+        font-weight: 600;
+    }
+    
+    
+    </style>
+    
+    <!-- 애니메이션 배경 -->
+    <div class="animated-background"></div>
+    """

utils/helpers.py

@@ -0,0 +1,69 @@
+# utils/helpers.py
+"""유틸리티 함수들"""
+import os
+from typing import Optional
+
+
+def ensure_dir(directory: str):
+    """
+    디렉토리가 없으면 생성
+    
+    Args:
+        directory: 디렉토리 경로
+    """
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+        print(f"📁 디렉토리 생성: {directory}")
+
+
+def format_file_size(size_bytes: int) -> str:
+    """
+    파일 크기를 읽기 쉬운 형식으로 변환
+    
+    Args:
+        size_bytes: 바이트 단위 크기
+    
+    Returns:
+        str: 포맷된 크기 (예: "1.5 MB")
+    """
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f} TB"
+
+
+def truncate_text(text: str, max_length: int = 100, suffix: str = "...") -> str:
+    """
+    텍스트를 지정된 길이로 자르기
+    
+    Args:
+        text: 원본 텍스트
+        max_length: 최대 길이
+        suffix: 잘린 경우 추가할 접미사
+    
+    Returns:
+        str: 잘린 텍스트
+    """
+    if len(text) <= max_length:
+        return text
+    return text[:max_length - len(suffix)] + suffix
+
+
+def safe_get(dictionary: dict, key: str, default: Optional[any] = None):
+    """
+    안전하게 딕셔너리 값 가져오기
+    
+    Args:
+        dictionary: 딕셔너리
+        key: 키
+        default: 기본값
+    
+    Returns:
+        값 또는 기본값
+    """
+    try:
+        return dictionary.get(key, default)
+    except:
+        return default
+

utils/logger.py

@@ -0,0 +1,41 @@
+# utils/logger.py
+"""로깅 유틸리티"""
+import logging
+from datetime import datetime
+
+
+def setup_logger(name: str = "TEAM_EA", level: int = logging.INFO) -> logging.Logger:
+    """
+    로거 설정
+    
+    Args:
+        name: 로거 이름
+        level: 로깅 레벨
+    
+    Returns:
+        logging.Logger: 설정된 로거
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    
+    # 핸들러가 이미 있으면 추가하지 않음
+    if not logger.handlers:
+        # 콘솔 핸들러
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+        
+        # 포맷터
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        console_handler.setFormatter(formatter)
+        
+        logger.addHandler(console_handler)
+    
+    return logger
+
+
+# 전역 로거
+logger = setup_logger()
+

utils/pdf_utils.py

@@ -0,0 +1,57 @@
+# utils/pdf_utils.py
+"""PDF 텍스트 좌표 추출 유틸"""
+import fitz  # PyMuPDF
+from typing import List, Dict
+
+
+def get_text_coordinates(pdf_path: str, page_num: int, search_text: str) -> List[Dict]:
+    """
+    PDF에서 특정 텍스트의 좌표를 찾아 하이라이트 정보 반환
+    
+    Args:
+        pdf_path: PDF 파일 경로
+        page_num: 페이지 번호 (1-based)
+        search_text: 검색할 텍스트
+    
+    Returns:
+        하이라이트 정보 리스트
+    """
+    try:
+        doc = fitz.open(pdf_path)
+        page = doc[page_num - 1]
+        
+        # 검색 텍스트 정리 (너무 길면 앞부분만)
+        search_query = search_text[:100].strip()
+        text_instances = page.search_for(search_query)
+        
+        annotations = []
+        
+        for rect in text_instances:
+            # streamlit-pdf-viewer 형식 - 형광펜 스타일
+            annotations.append({
+                "page": page_num,  # 1-based index
+                "x": rect.x0,
+                "y": rect.y0,
+                "width": rect.x1 - rect.x0,
+                "height": rect.y1 - rect.y0,
+                "color": "#FFFF00",  # 밝은 노란색
+                "opacity": 0.4  # 40% 투명도 (형광펜 효과)
+            })
+        
+        doc.close()
+        
+        if annotations:
+            print(f"   ✅ {len(annotations)}개 하이라이트 생성 (페이지 {page_num})")
+        else:
+            print(f"   ⚠️ 텍스트 '{search_query[:30]}...' 찾지 못함")
+        
+        return annotations
+        
+    except Exception as e:
+        print(f"❌ 하이라이트 생성 오류: {e}")
+        return []
+
+
+if __name__ == "__main__":
+    result = get_text_coordinates("test.pdf", 1, "sample text")
+    print(f"하이라이트 개수: {len(result)}")