Upgrade to OpenAI + Supabase RAG Chatbot with enhanced capabilities

## Major Features Added:
- OpenAI GPT-4o-mini integration for advanced responses
- Supabase pgvector cloud database for scalable vector storage
- Hybrid support: Choose between FAISS (local) or Supabase (cloud)
- OpenAI text-embedding-3-small for improved embeddings
- Environment-based configuration system

## New Files:
- openai_chatbot.py: OpenAI-powered RAG chatbot
- supabase_vector_store.py: Cloud vector database integration
- supabase_setup*.sql: Database setup scripts (3 variants)
- .env.example: Configuration template
- .gitignore: Python and application-specific ignores

## Enhanced Configuration:
- Support for multiple vector database backends
- OpenAI API key and Supabase credentials
- Flexible embedding model selection
- Environment variable-based settings

## Bug Fixes:
- Fixed LangChain import compatibility issues
- Resolved PyMuPDF import problems
- Updated to latest package versions

🚀 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,109 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.env.venv
+.env.local
+.env.*.local
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDEs
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Application specific
+faiss_index/
+*.bin
+*.pkl
+
+# Vector databases
+faiss_index/

README.md

@@ -16,9 +16,9 @@ pinned: false
 ## 📋 프로젝트 개요
 
 - **목적**: 소방업무 복무관리 관련 문서들을 활용한 지능형 질의응답 시스템
-- **기술**: RAG, Sentence-BERT, FAISS, Gradio, Hugging Face
+- **기술**: RAG, OpenAI GPT, Supabase pgvector, Sentence-BERT, Gradio
 - **문서 유형**: PDF, Word, TXT, Excel, CSV
-- **특징**: 한국어 최적화, 실시간 검색, 웹 인터페이스
+- **특징**: 한국어 최적화, 실시간 검색, 클라우드 벡터 DB, 웹 인터페이스
 
 ## 🎯 주요 기능
 
@@ -78,7 +78,28 @@ source venv/bin/activate
 pip install -r requirements.txt
 ```
 
-### 2. 문서 준비
+### 2. OpenAI API 설정 (권장)
+
+```bash
+# OpenAI API Key 발급: https://platform.openai.com/api-keys
+# .env 파일에 설정
+echo "OPENAI_API_KEY=sk-your-api-key-here" >> .env
+```
+
+### 3. Supabase 설정 (권장 - 클라우드 벡터 DB)
+
+```bash
+# 1. Supabase 프로젝트 생성: https://supabase.com
+# 2. SQL Editor에서 supabase_setup.sql 실행
+# 3. Settings > API에서 URL과 Key 확인
+
+# .env 파일에 Supabase 설정 추가
+echo "SUPABASE_URL=https://your-project.supabase.co" >> .env
+echo "SUPABASE_KEY=your-supabase-anon-key" >> .env
+echo "VECTOR_DB_TYPE=supabase" >> .env
+```
+
+### 4. 문서 준비
 
 ```bash
 # documents 폴더 생성
@@ -108,40 +129,72 @@ python app.py
 
 ```
 119_chatbot/
-├── app.py                   # 허깅페이스 배포용 메인 파일
-├── config.py               # 시스템 설정
-├── requirements.txt        # 라이브러리 목록
-├── README.md              # 프로젝트 설명서
-├── document_processor.py  # 문서 처리 모듈
-├── vector_store.py        # 벡터 데이터베이스
-├── rag_chatbot.py         # RAG 챗봇 핵심 로직
-├── gradio_interface.py    # Gradio 웹 인터페이스
-├── documents/             # 문서 폴더
+├── app.py                     # 허깅페이스 배포용 메인 파일
+├── config.py                 # 시스템 설정
+├── requirements.txt          # 라이브러리 목록
+├── README.md                # 프로젝트 설명서
+├── .env.example             # 환경 변수 템플릿
+├── supabase_setup.sql       # Supabase 설정 SQL
+├── document_processor.py    # 문서 처리 모듈
+├── vector_store.py          # FAISS 벡터 데이터베이스
+├── supabase_vector_store.py # Supabase 벡터 데이터베이스
+├── rag_chatbot.py           # 기존 RAG 챗봇
+├── openai_chatbot.py        # OpenAI 기반 RAG 챗봇
+├── gradio_interface.py      # Gradio 웹 인터페이스
+├── documents/               # 문서 폴더
 │   ├── 복무관리규정.txt
 │   ├── 인사평가규정.txt
 │   └── ...
-└── faiss_index/           # 벡터 인덱스 캐시
+└── faiss_index/             # 벡터 인덱스 캐시 (FAISS 사용시)
 ```
 
 ## ⚙️ 설정 옵션
 
+### 환경 변수 설정 (.env 파일)
+
+```bash
+# OpenAI API (필수)
+OPENAI_API_KEY=sk-your-openai-api-key
+OPENAI_MODEL=gpt-4o-mini
+OPENAI_EMBEDDING_MODEL=text-embedding-3-small
+
+# Supabase (클라우드 벡터 DB 사용시 필수)
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your-supabase-anon-key
+
+# 벡터 DB 타입 선택
+VECTOR_DB_TYPE=supabase    # "supabase" 또는 "faiss"
+```
+
 ### config.py 주요 설정
 
 ```python
-# 모델 설정
-EMBEDDING_MODEL = "jhgan/ko-sbert-nli"      # 한국어 임베딩 모델
-LLM_MODEL = "beomi/Llama-3-Open-Ko-8B"      # 한국어 LLM
-
 # RAG 파라미터
 CHUNK_SIZE = 500                            # 문서 청크 크기
 CHUNK_OVERLAP = 50                          # 청크 중복 크기
 MAX_RETRIEVE_DOCS = 3                       # 검색할 문서 수
 
+# 기존 로컬 모델 설정 (FAISS 사용시)
+EMBEDDING_MODEL = "jhgan/ko-sbert-nli"      # 한국어 임베딩 모델
+LLM_MODEL = "beomi/Llama-3-Open-Ko-8B"      # 한국어 LLM
+
 # 경로 설정
 DOCS_FOLDER = "documents"                   # 문서 폴더
 VECTOR_DB_PATH = "faiss_index"             # 벡터 DB 경로
 ```
 
+### 🔄 벡터 DB 옵션
+
+#### 1. Supabase (권장) - 클라우드 벡터 DB
+- **장점**: 클라우드 저장, 확장성, 동시성, 실시간 동기화
+- **필요사항**: OpenAI API Key, Supabase 프로젝트
+- **설정**: `VECTOR_DB_TYPE=supabase`
+
+#### 2. FAISS (로컬) - 오프라인 벡터 DB
+- **장점**: 로컬 실행, 무료, 빠른 초기 설정
+- **단점**: 로컬 저장 공간 필요, 확장성 제한
+- **설정**: `VECTOR_DB_TYPE=faiss`
+
 ## 🧪 사용 예시
 
 ### 기본 질문

app.py

@@ -19,13 +19,18 @@ sys.path.append(current_dir)
 # 모듈 임포트
 from config import Config
 from rag_chatbot import RAGChatbot
+from openai_chatbot import OpenAIRAGChatbot
 from document_processor import DocumentProcessor
 
 class HuggingFaceApp:
     """허깅페이스 Spaces 배포용 앱 클래스"""
 
     def __init__(self):
-        self.chatbot = RAGChatbot()
+        # 벡터 DB 타입에 따라 챗봇 선택
+        if Config.VECTOR_DB_TYPE == "supabase":
+            self.chatbot = OpenAIRAGChatbot()
+        else:
+            self.chatbot = RAGChatbot()
         self.is_initialized = False
 
         # 예시 질문 (허깅페이스 환경 최적화)
@@ -44,7 +49,7 @@ class HuggingFaceApp:
     def _initialize_app(self):
         """앱 초기화"""
         try:
-            print("🚀 소방 복무관리 RAG 챗봇 시작 중...")
+            print("Starting Fire Service Management RAG Chatbot...")
 
             # 문서 폴더 확인 및 샘플 데이터 생성
             self._ensure_documents()
@@ -53,12 +58,12 @@ class HuggingFaceApp:
             success = self.chatbot.initialize()
             if success:
                 self.is_initialized = True
-                print("✅ 챗봇 초기화 완료")
+                print("Chatbot initialization completed")
             else:
-                print("⚠️ 챗봇 초기화 실패 - 템플릿 모드로 동작")
+                print("Chatbot initialization failed - running in template mode")
 
         except Exception as e:
-            print(f"❌ 초기화 오류: {str(e)}")
+            print(f"Initialization error: {str(e)}")
             # 오류가 있어도 앱은 계속 실행
 
     def _ensure_documents(self):
@@ -69,7 +74,7 @@ class HuggingFaceApp:
         # 샘플 문서가 없으면 생성
         sample_files = list(docs_folder.glob("*.txt"))
         if not sample_files:
-            print("📝 샘플 문서 생성 중...")
+            print("Creating sample documents...")
             self._create_sample_documents()
 
     def _create_sample_documents(self):

config.py

@@ -28,6 +28,18 @@ class Config:
     # 토큰 설정 (필요시)
     HUGGINGFACE_TOKEN = os.getenv("HUGGINGFACE_TOKEN", "")
 
+    # Supabase 설정
+    SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+    SUPABASE_KEY = os.getenv("SUPABASE_KEY", "")
+
+    # OpenAI 설정
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+    OPENAI_MODEL = "gpt-4o-mini"  # 또는 "gpt-3.5-turbo"
+    OPENAI_EMBEDDING_MODEL = "text-embedding-3-small"
+
+    # 벡터 DB 타입 설정
+    VECTOR_DB_TYPE = os.getenv("VECTOR_DB_TYPE", "supabase")  # "faiss" 또는 "supabase"
+
     # 시스템 프롬프트
     SYSTEM_PROMPT = """
     당신은 소방업무 복무관리 전문가입니다. 복무관리 규정, 인사운영, 근무절차 등에 대한 질문에 정확하고 친절하게 답변해 주세요.

document_processor.py

@@ -2,11 +2,11 @@ import os
 import re
 from typing import List, Dict
 from pathlib import Path
-import PyMuPDF
+import fitz  # PyMuPDF
 import docx
 import pandas as pd
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.schema import Document
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
 
 class DocumentProcessor:
     """복무관리 문서 처리 클래스"""
@@ -63,7 +63,7 @@ class DocumentProcessor:
         documents = []
 
         try:
-            with PyMuPDF.open(file_path) as doc:
+            with fitz.open(file_path) as doc:
                 full_text = ""
 
                 for page_num in range(len(doc)):

documents/복무관리규정.txt

@@ -0,0 +1,20 @@
+소방공무원 복무관리 규정
+
+제1장 총칙
+제1조 (목적)
+이 규정은 소방공무원의 복무에 관한 기본사항을 규정하여 직무수행의 효율성을 높이고 조직의 발전에 기여함을 목적으로 한다.
+
+제2조 (근무시간)
+1. 정규근무시간은 09:00부터 18:00까지로 한다.
+2. 점심시간은 12:00부터 13:00까지로 한다.
+3. 토요일, 일요일 및 법정공휴일은 휴무일로 한다.
+
+제3조 (연차휴가)
+1. 연차휴가는 1년간 정상 근무한 자에게 15일을 부여한다.
+2. 연차휴가 사용 시 3일 전까지 신청서를 제출해야 한다.
+3. 부서장의 승인을 받아 사용하며, 긴급한 경우에는 사후 승인도 가능하다.
+
+제4조 (당직근무)
+1. 당직근무는 정규근무시간 외에 수행하는 근무를 말한다.
+2. 당직자는 비상상황에 대비한 통신장비를 항시 점검해야 한다.
+3. 당직 중에는 음주를 엄금하며, 직무 수행에 지장이 없는 행위만 가능하다.

openai_chatbot.py

@@ -0,0 +1,299 @@
+import os
+import time
+from typing import List, Dict, Tuple
+from dataclasses import dataclass
+import openai
+from supabase_vector_store import SupabaseVectorStore
+from document_processor import DocumentProcessor
+from config import Config
+
+@dataclass
+class ChatResponse:
+    """챗봇 응답 결과 클래스"""
+    answer: str
+    sources: List[Dict]
+    confidence: float
+    response_time: float
+
+class OpenAIRAGChatbot:
+    """OpenAI 기반 RAG 챗봇"""
+
+    def __init__(self):
+        self.document_processor = DocumentProcessor(
+            chunk_size=Config.CHUNK_SIZE,
+            chunk_overlap=Config.CHUNK_OVERLAP
+        )
+        self.vector_store = None
+        self.openai_client = None
+        self.is_initialized = False
+
+    def initialize(self, docs_folder: str = None, force_rebuild: bool = False) -> bool:
+        """챗봇 초기화"""
+        print("🤖 OpenAI 기반 소방 복무관리 RAG 챗봇 초기화 중...")
+
+        # 1. OpenAI 클라이언트 초기화
+        if not Config.OPENAI_API_KEY:
+            print("❌ OpenAI API Key가 설정되지 않았습니다.")
+            return False
+
+        self.openai_client = openai.OpenAI(api_key=Config.OPENAI_API_KEY)
+
+        # 2. 벡터 저장소 초기화
+        try:
+            self.vector_store = SupabaseVectorStore()
+        except Exception as e:
+            print(f"❌ 벡터 저장소 초기화 실패: {str(e)}")
+            return False
+
+        # 3. 문서 로드 및 처리
+        docs_folder = docs_folder or Config.DOCS_FOLDER
+        documents = self._load_documents(docs_folder)
+
+        if not documents:
+            print("❌ 처리할 문서가 없습니다. documents 폴더에 파일을 넣어주세요.")
+            return False
+
+        # 4. 벡터 데이터베이스 구축
+        success = self.vector_store.rebuild_index(documents, force_rebuild, use_openai=True)
+        if not success:
+            print("❌ 벡터 데이터베이스 구축 실패")
+            return False
+
+        self.is_initialized = True
+        print("✅ OpenAI RAG 챗봇 초기화 완료")
+        return True
+
+    def _load_documents(self, docs_folder: str) -> List:
+        """문서 로드 및 처리"""
+        if not os.path.exists(docs_folder):
+            print(f"⚠️ 문서 폴더가 존재하지 않습니다: {docs_folder}")
+            return []
+
+        print(f"📂 문서 폴더: {docs_folder}")
+        raw_documents = self.document_processor.load_documents_from_folder(docs_folder)
+        processed_documents = self.document_processor.process_documents(raw_documents)
+
+        print(f"✅ 총 {len(processed_documents)}개 문서 청크 생성 완료")
+        return processed_documents
+
+    def search_relevant_docs(self, query: str, k: int = 3) -> List[Tuple]:
+        """관련 문서 검색"""
+        if not self.is_initialized:
+            print("⚠️ 챗봇이 초기화되지 않았습니다.")
+            return []
+
+        # 쿼리 전처리
+        processed_query = self._preprocess_query(query)
+
+        # 벡터 검색
+        results = self.vector_store.search_similar(processed_query, k, use_openai=True)
+
+        # 유사도 필터링
+        filtered_results = [
+            (doc, similarity) for doc, similarity in results
+            if similarity > 0.3  # 최소 유사도 임계값
+        ]
+
+        return filtered_results
+
+    def _preprocess_query(self, query: str) -> str:
+        """쿼리 전처리"""
+        import re
+
+        # 불필요한 공백 제거
+        query = re.sub(r'\s+', ' ', query.strip())
+
+        # 복무관리 관련 키워드 강화
+        keyword_mappings = {
+            "연차": "연차휴가",
+            "휴가": "휴가사용",
+            "근무": "근무시간",
+            "당직": "당직근무",
+            "인사": "인사평가",
+            "승진": "승진시험"
+        }
+
+        for keyword, enhanced in keyword_mappings.items():
+            if keyword in query and enhanced not in query:
+                query = query.replace(keyword, enhanced)
+
+        return query
+
+    def generate_answer(self, query: str) -> ChatResponse:
+        """질문에 대한 답변 생성 (OpenAI 사용)"""
+        start_time = time.time()
+
+        if not self.is_initialized:
+            return ChatResponse(
+                answer="죄송합니다. 챗봇이 초기화되지 않았습니다. 관리자에게 문의해주세요.",
+                sources=[],
+                confidence=0.0,
+                response_time=time.time() - start_time
+            )
+
+        # 1. 관련 문서 검색
+        relevant_docs = self.search_relevant_docs(query, k=Config.MAX_RETRIEVE_DOCS)
+
+        if not relevant_docs:
+            return ChatResponse(
+                answer="죄송합니다. 질문과 관련된 정보를 찾을 수 없습니다. 다른 방식으로 질문해주시거나 관련 부서에 문의해주시기 바랍니다.",
+                sources=[],
+                confidence=0.0,
+                response_time=time.time() - start_time
+            )
+
+        # 2. OpenAI로 답변 생성
+        answer = self._generate_openai_answer(query, relevant_docs)
+
+        # 3. 출처 정보 준비
+        sources = [
+            {
+                "source": doc.metadata.get("source", "알 수 없음"),
+                "content": doc.page_content[:200] + "..." if len(doc.page_content) > 200 else doc.page_content,
+                "similarity": f"{similarity:.4f}"
+            }
+            for doc, similarity in relevant_docs
+        ]
+
+        # 4. 신뢰도 계산
+        confidence = min(sum(similarity for _, similarity in relevant_docs) / len(relevant_docs), 1.0)
+
+        return ChatResponse(
+            answer=answer,
+            sources=sources,
+            confidence=confidence,
+            response_time=time.time() - start_time
+        )
+
+    def _generate_openai_answer(self, query: str, relevant_docs: List[Tuple]) -> str:
+        """OpenAI로 답변 생성"""
+        try:
+            # 문맥 구성
+            context = "\n\n".join([
+                f"[출처 {i+1}] {doc.page_content}"
+                for i, (doc, _) in enumerate(relevant_docs)
+            ])
+
+            # OpenAI API 호출
+            messages = [
+                {
+                    "role": "system",
+                    "content": f"""{Config.SYSTEM_PROMPT}
+
+답변 시 다음 지침을 따르세요:
+1. 반드시 아래 참고자료를 기반으로 답변하세요
+2. 규정 조문이나 구체적인 절차를 명시하세요
+3. 단계별 설명이 필요한 경우 번호로 구분해서 설명하세요
+4. 필요한 서류나 양식을 구체적으로 안내하세요
+5. 주의사항이나 중요 사항은 강조해주세요
+6. 답변 마지막에 참고한 출처를 표시하세요"""
+                },
+                {
+                    "role": "user",
+                    "content": f"""[참고자료]
+{context}
+
+[질문]
+{query}
+
+위 참고자료를 바탕으로 질문에 답변해주세요. 정확하고 친절하게 설명해주세요."""
+                }
+            ]
+
+            response = self.openai_client.chat.completions.create(
+                model=Config.OPENAI_MODEL,
+                messages=messages,
+                max_tokens=2000,
+                temperature=0.3,  # 더 일관된 답변을 위해 낮은 온도
+                top_p=0.9
+            )
+
+            answer = response.choices[0].message.content.strip()
+            return answer
+
+        except Exception as e:
+            print(f"⚠️ OpenAI 답변 생성 실패: {str(e)}")
+            return self._generate_fallback_answer(query, relevant_docs)
+
+    def _generate_fallback_answer(self, query: str, relevant_docs: List[Tuple]) -> str:
+        """OpenAI 실패 시 대체 답변 생성"""
+        top_doc, top_similarity = relevant_docs[0]
+
+        answer = f"""📋 소방 복무관리 안내
+
+질문: {query}
+
+관련 정보:
+{top_doc.page_content[:800]}...
+
+📖 더 자세한 정보는 관련 규정 파일을 확인하시거나 담당 부서에 문의해주시기 바랍니다.
+
+*참고자료 유사도: {top_similarity:.2%}*"""
+
+        return answer
+
+    def get_stats(self) -> Dict:
+        """챗봇 통계 정보"""
+        if not self.is_initialized:
+            return {"status": "not_initialized"}
+
+        vector_stats = self.vector_store.get_stats()
+
+        return {
+            "status": "initialized",
+            "vector_store": vector_stats,
+            "llm_provider": "openai",
+            "llm_model": Config.OPENAI_MODEL,
+            "embedding_model": Config.OPENAI_EMBEDDING_MODEL
+        }
+
+    def add_documents(self, documents: List) -> bool:
+        """새 문서 추가"""
+        if not self.is_initialized:
+            print("⚠️ 챗봇이 초기화되지 않았습니다.")
+            return False
+
+        return self.vector_store.add_documents(documents, use_openai=True)
+
+# 테스트용 함수
+def test_openai_chatbot():
+    """OpenAI RAG 챗봇 테스트"""
+    # 환경 변수 확인
+    if not Config.OPENAI_API_KEY:
+        print("❌ OPENAI_API_KEY 환경 변수가 필요합니다.")
+        return
+
+    if not Config.SUPABASE_URL or not Config.SUPABASE_KEY:
+        print("❌ SUPABASE_URL, SUPABASE_KEY 환경 변수가 필요합니다.")
+        return
+
+    # 챗봇 초기화
+    chatbot = OpenAIRAGChatbot()
+    success = chatbot.initialize()
+
+    if not success:
+        return
+
+    # 테스트 질문
+    test_questions = [
+        "연차휴가는 어떻게 사용하나요?",
+        "정규근무시간은 어떻게 되나요?",
+        "당직근무가 무엇인가요?",
+        "인사평가 절차가 궁금합니다."
+    ]
+
+    # 질문 테스트
+    for question in test_questions:
+        print(f"\n❓ 질문: {question}")
+        response = chatbot.generate_answer(question)
+
+        print(f"🤖 답변: {response.answer[:500]}...")
+        print(f"📊 신뢰도: {response.confidence:.4f}")
+        print(f"⏱️ 응답시간: {response.response_time:.4f}초")
+        print(f"📚 출처: {len(response.sources)}개")
+
+    # 통계 정보
+    print(f"\n📈 챗봇 통계: {chatbot.get_stats()}")
+
+if __name__ == "__main__":
+    test_openai_chatbot()

rag_chatbot.py

@@ -4,7 +4,7 @@ from typing import List, Dict, Tuple
 from dataclasses import dataclass
 import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-from langchain.schema import Document
+from langchain_core.documents import Document
 from document_processor import DocumentProcessor
 from vector_store import VectorStore
 from config import Config

requirements.txt

@@ -24,6 +24,10 @@ python-docx>=1.1.0
 openpyxl>=3.1.2
 PyMuPDF>=1.23.8
 
+# Supabase
+supabase>=2.0.0
+openai>=1.0.0
+
 # 유틸리티
 python-dotenv>=1.0.0
 tqdm>=4.66.0

supabase_setup.sql

@@ -0,0 +1,99 @@
+-- Supabase pgvector 설정 SQL
+-- 이 SQL을 Supabase Dashboard > SQL Editor에서 실행하세요
+
+-- 1. pgvector 확장 활성화
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- 2. documents 테이블 생성
+CREATE TABLE IF NOT EXISTS documents (
+    id SERIAL PRIMARY KEY,
+    content TEXT NOT NULL,
+    metadata JSONB,
+    embedding vector(1536),  -- OpenAI text-embedding-3-small 차원
+    source_file VARCHAR(255),
+    chunk_index INTEGER,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- 3. 벡터 유사도 검색을 위한 인덱스 생성
+CREATE INDEX IF NOT EXISTS documents_embedding_idx
+ON documents
+USING ivfflat (embedding vector_cosine_ops)
+WITH (lists = 100);
+
+-- 4. 전문 검색을 위한 인덱스 생성 (기본 영어 설정)
+CREATE INDEX IF NOT EXISTS documents_content_idx
+ON documents
+USING gin(to_tsvector('english', content));
+
+-- 5. 소스 파일별 검색 인덱스
+CREATE INDEX IF NOT EXISTS documents_source_file_idx
+ON documents (source_file);
+
+-- 6. 벡터 유사도 검색 함수 생성
+CREATE OR REPLACE FUNCTION search_similar_documents(
+    query_embedding vector(1536),
+    match_threshold float DEFAULT 0.5,
+    match_count int DEFAULT 10
+)
+RETURNS TABLE (
+    id int,
+    content text,
+    metadata jsonb,
+    source_file varchar(255),
+    similarity float
+) AS $$
+BEGIN
+    RETURN QUERY
+    SELECT
+        d.id,
+        d.content,
+        d.metadata,
+        d.source_file,
+        1 - (d.embedding <=> query_embedding) as similarity
+    FROM documents d
+    WHERE 1 - (d.embedding <=> query_embedding) > match_threshold
+    ORDER BY similarity DESC
+    LIMIT match_count;
+END;
+$$ LANGUAGE plpgsql;
+
+-- 7. 자동 타임스탬프 업데이트 함수
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- 8. documents 테이블에 트리거 추가
+CREATE TRIGGER update_documents_updated_at
+    BEFORE UPDATE ON documents
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- 9. RLS (Row Level Security) 설정 (선택사항)
+ALTER TABLE documents ENABLE ROW LEVEL SECURITY;
+
+-- 10. 읽기 권한 정책 (인증된 사용자에게 허용)
+CREATE POLICY "Enable read access for all authenticated users" ON documents
+    FOR SELECT USING (auth.role() = 'authenticated');
+
+-- 11. 쓰기 권한 정책 (서비스 롤에게 허용)
+CREATE POLICY "Enable write access for service role" ON documents
+    FOR ALL USING (auth.role() = 'service_role')
+    WITH CHECK (auth.role() = 'service_role');
+
+-- 12. 초기 데이터 확인용 쿼리
+SELECT 'Setup completed successfully!' as status;
+
+-- 13. 테이블 정보 확인
+SELECT
+    column_name,
+    data_type,
+    is_nullable
+FROM information_schema.columns
+WHERE table_name = 'documents'
+ORDER BY ordinal_position;

supabase_setup_minimal.sql

@@ -0,0 +1,25 @@
+-- 가장 기본적인 Supabase 설정
+-- 모든 복잡한 기능을 제거하고 최소한의 기능만 포함
+
+-- 1. pgvector 확장 활성화
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- 2. 가장 간단한 documents 테이블 생성
+CREATE TABLE IF NOT EXISTS documents (
+    id SERIAL PRIMARY KEY,
+    content TEXT NOT NULL,
+    metadata JSONB DEFAULT '{}',
+    embedding vector(1536),  -- OpenAI text-embedding-3-small 차원
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- 3. 성공 메시지
+SELECT 'Minimal Supabase setup completed!' as status;
+
+-- 4. 테이블 구조 확인
+SELECT
+    column_name,
+    data_type
+FROM information_schema.columns
+WHERE table_name = 'documents'
+ORDER BY ordinal_position;

supabase_setup_simple.sql

@@ -0,0 +1,55 @@
+-- 간단한 Supabase 설정 SQL
+-- 이 버전은 기본 기능만 포함하여 호환성을 높입니다.
+
+-- 1. pgvector 확장 활성화
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- 2. documents 테이블 생성 (필수 항목만)
+CREATE TABLE IF NOT EXISTS documents (
+    id SERIAL PRIMARY KEY,
+    content TEXT NOT NULL,
+    metadata JSONB DEFAULT '{}',
+    embedding vector(1536),  -- OpenAI text-embedding-3-small 차원
+    source_file VARCHAR(255),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- 3. 기본 인덱스 생성 (테이블 생성 후)
+CREATE INDEX IF NOT EXISTS documents_created_at_idx
+ON documents (created_at);
+
+-- 4. 벡터 유사도 검색 함수 (가장 간단한 버전)
+CREATE OR REPLACE FUNCTION search_similar_documents(
+    query_embedding vector(1536),
+    match_count int DEFAULT 10
+)
+RETURNS TABLE (
+    id int,
+    content text,
+    metadata jsonb,
+    similarity float
+) AS $$
+BEGIN
+    RETURN QUERY
+    SELECT
+        d.id,
+        d.content,
+        d.metadata,
+        1 - (d.embedding <=> query_embedding) as similarity
+    FROM documents d
+    ORDER BY d.embedding <=> query_embedding
+    LIMIT match_count;
+END;
+$$ LANGUAGE plpgsql;
+
+-- 5. 성공 메시지
+SELECT 'Supabase setup completed successfully!' as status;
+
+-- 6. 테이블 구조 확인
+SELECT
+    column_name,
+    data_type,
+    is_nullable
+FROM information_schema.columns
+WHERE table_name = 'documents'
+ORDER BY ordinal_position;

supabase_vector_store.py

@@ -0,0 +1,324 @@
+import os
+import json
+import numpy as np
+from typing import List, Dict, Tuple, Optional
+from supabase import create_client, Client
+from langchain_core.documents import Document
+from sentence_transformers import SentenceTransformer
+import openai
+from config import Config
+
+class SupabaseVectorStore:
+    """Supabase pgvector 기반 벡터 데이터베이스 클래스"""
+
+    def __init__(self, embedding_model: str = None):
+        self.embedding_model_name = embedding_model or Config.EMBEDDING_MODEL
+        self.model = None
+        self.supabase: Optional[Client] = None
+        self.table_name = "documents"
+
+        # Supabase 클라이언트 초기화
+        self._init_supabase()
+
+    def _init_supabase(self):
+        """Supabase 클라이언트 초기화"""
+        try:
+            if not Config.SUPABASE_URL or not Config.SUPABASE_KEY:
+                raise ValueError("Supabase URL과 Key가 필요합니다.")
+
+            self.supabase = create_client(Config.SUPABASE_URL, Config.SUPABASE_KEY)
+            print("✅ Supabase 클라이언트 연결 성공")
+
+            # 테이블이 없으면 생성 (필요시)
+            self._create_table_if_not_exists()
+
+        except Exception as e:
+            print(f"❌ Supabase 연결 실패: {str(e)}")
+            raise
+
+    def _create_table_if_not_exists(self):
+        """테이블 생성 (SQL 실행 필요시 관리자에서 직접 실행)"""
+        # 아래 SQL은 Supabase SQL 에디터에서 직접 실행해야 함
+        create_table_sql = f"""
+        -- Enable pgvector extension
+        CREATE EXTENSION IF NOT EXISTS vector;
+
+        -- Create documents table
+        CREATE TABLE IF NOT EXISTS {self.table_name} (
+            id SERIAL PRIMARY KEY,
+            content TEXT NOT NULL,
+            metadata JSONB,
+            embedding vector(1536),  -- OpenAI embedding 차원
+            source_file VARCHAR(255),
+            created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+            updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+        );
+
+        -- Create index for vector similarity search
+        CREATE INDEX IF NOT EXISTS documents_embedding_idx ON {self.table_name}
+        USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
+
+        -- Create full-text search index
+        CREATE INDEX IF NOT EXISTS documents_content_idx ON {self.table_name}
+        USING gin(to_tsvector('korean', content));
+        """
+
+        print(f"📝 아래 SQL을 Supabase SQL 에디터에서 실행해주세요:")
+        print(create_table_sql)
+
+    def load_embedding_model(self, use_openai: bool = True):
+        """임베딩 모델 로드"""
+        if self.model is not None:
+            return
+
+        if use_openai and Config.OPENAI_API_KEY:
+            print("📥 OpenAI 임베딩 모델 사용")
+            self.model = "openai"
+        else:
+            print(f"📥 임베딩 모델 로드: {self.embedding_model_name}")
+            try:
+                self.model = SentenceTransformer(self.embedding_model_name)
+                print("✅ 임베딩 모델 로드 완료")
+            except Exception as e:
+                print(f"❌ 임베딩 모델 로드 실패: {str(e)}")
+                print("🔄 다국어 모델로 대체 시도...")
+                self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
+
+    def create_embeddings(self, texts: List[str], use_openai: bool = True) -> np.ndarray:
+        """텍스트 목록에 대한 임베딩 생성"""
+        if self.model is None:
+            self.load_embedding_model(use_openai)
+
+        print(f"🔄 {len(texts)}개 텍스트 임베딩 생성 중...")
+
+        if self.model == "openai" and Config.OPENAI_API_KEY:
+            # OpenAI API 사용
+            client = openai.OpenAI(api_key=Config.OPENAI_API_KEY)
+            embeddings = []
+
+            for i in range(0, len(texts), 100):  # 배치 사이즈 100
+                batch_texts = texts[i:i+100]
+                response = client.embeddings.create(
+                    model=Config.OPENAI_EMBEDDING_MODEL,
+                    input=batch_texts
+                )
+                batch_embeddings = [item.embedding for item in response.data]
+                embeddings.extend(batch_embeddings)
+
+            return np.array(embeddings)
+        else:
+            # 로컬 모델 사용
+            return self.model.encode(
+                texts,
+                batch_size=32,
+                show_progress_bar=True,
+                convert_to_numpy=True,
+                normalize_embeddings=True
+            )
+
+    def add_documents(self, documents: List[Document], use_openai: bool = True) -> bool:
+        """문서 추가"""
+        if not documents:
+            print("⚠️ 추가할 문서가 없습니다.")
+            return False
+
+        print(f"📝 {len(documents)}개 문서를 Supabase에 추가 중...")
+
+        try:
+            # 임베딩 생성
+            texts = [doc.page_content for doc in documents]
+            embeddings = self.create_embeddings(texts, use_openai)
+
+            # 문서 데이터 준비
+            documents_data = []
+            for i, doc in enumerate(documents):
+                doc_data = {
+                    'content': doc.page_content,
+                    'metadata': doc.metadata,
+                    'embedding': embeddings[i].tolist()
+                }
+                documents_data.append(doc_data)
+
+            # 배치로 데이터 삽입
+            batch_size = 100
+            for i in range(0, len(documents_data), batch_size):
+                batch = documents_data[i:i+batch_size]
+                result = self.supabase.table(self.table_name).insert(batch).execute()
+
+                if not result.data:
+                    print(f"❌ 배치 삽입 실패 (배치 {i//batch_size + 1})")
+                    return False
+
+            print(f"✅ {len(documents)}개 문서 추가 완료")
+            return True
+
+        except Exception as e:
+            print(f"❌ 문서 추가 실패: {str(e)}")
+            return False
+
+    def search_similar(self, query: str, k: int = 5, use_openai: bool = True) -> List[Tuple[Document, float]]:
+        """유사 문서 검색"""
+        if self.supabase is None:
+            print("⚠️ Supabase 클라이언트가 초기화되지 않았습니다.")
+            return []
+
+        if self.model is None:
+            self.load_embedding_model(use_openai)
+
+        try:
+            # 쿼리 임베딩 생성
+            if self.model == "openai" and Config.OPENAI_API_KEY:
+                client = openai.OpenAI(api_key=Config.OPENAI_API_KEY)
+                response = client.embeddings.create(
+                    model=Config.OPENAI_EMBEDDING_MODEL,
+                    input=[query]
+                )
+                query_embedding = response.data[0].embedding
+            else:
+                query_embedding = self.model.encode([query], normalize_embeddings=True)[0]
+                query_embedding = query_embedding.tolist()
+
+            # 유사도 검색 SQL
+            match_threshold = 0.5
+            match_count = k
+
+            search_sql = f"""
+            SELECT content, metadata, source_file, 1 - (embedding <=> '[{','.join(map(str, query_embedding))}]') as similarity
+            FROM {self.table_name}
+            WHERE 1 - (embedding <=> '[{','.join(map(str, query_embedding))}]') > {match_threshold}
+            ORDER BY similarity DESC
+            LIMIT {match_count}
+            """
+
+            # Supabase RPC 호출
+            result = self.supabase.rpc('search_similar_documents', {
+                'query_embedding': query_embedding,
+                'match_threshold': match_threshold,
+                'match_count': match_count
+            }).execute()
+
+            if not result.data:
+                # RPC가 없으면 직접 SQL 실행 (권한 필요)
+                result = self.supabase.table(self.table_name).select(
+                    "content, metadata, source_file"
+                ).execute()
+
+                # 클라이언트 측에서 유사도 계산
+                if result.data:
+                    similarities = []
+                    for row in result.data:
+                        # 저장된 임베딩이 없으면 스킵
+                        if not row.get('embedding'):
+                            continue
+                        similarity = self._cosine_similarity(query_embedding, row['embedding'])
+                        if similarity > match_threshold:
+                            similarities.append((row, similarity))
+
+                    # 유사도로 정렬
+                    similarities.sort(key=lambda x: x[1], reverse=True)
+                    result.data = [item[0] for item in similarities[:k]]
+
+            # 결과 변환
+            results = []
+            for row in result.data[:k]:
+                doc = Document(
+                    page_content=row['content'],
+                    metadata=row.get('metadata', {}),
+                    id=row.get('id')
+                )
+                similarity = row.get('similarity', 1.0)  # 기본값 1.0
+                results.append((doc, float(similarity)))
+
+            return results
+
+        except Exception as e:
+            print(f"❌ 검색 실패: {str(e)}")
+            return []
+
+    def _cosine_similarity(self, vec1: List[float], vec2: List[float]) -> float:
+        """코사인 유사도 계산"""
+        vec1 = np.array(vec1)
+        vec2 = np.array(vec2)
+
+        dot_product = np.dot(vec1, vec2)
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+
+        return dot_product / (norm1 * norm2)
+
+    def delete_all_documents(self) -> bool:
+        """모든 문서 삭제"""
+        try:
+            result = self.supabase.table(self.table_name).delete().execute()
+            print("✅ 모든 문서 삭제 완료")
+            return True
+        except Exception as e:
+            print(f"❌ 문서 삭제 실패: {str(e)}")
+            return False
+
+    def get_stats(self) -> Dict:
+        """벡터 데이터베이스 통계 정보"""
+        try:
+            result = self.supabase.table(self.table_name).select("count", count="exact").execute()
+            total_docs = result.count if hasattr(result, 'count') else 0
+
+            return {
+                "total_documents": total_docs,
+                "embedding_model": self.embedding_model_name,
+                "database_type": "supabase",
+                "table_name": self.table_name
+            }
+        except Exception as e:
+            print(f"❌ 통계 정보 조회 실패: {str(e)}")
+            return {"status": "error", "message": str(e)}
+
+    def rebuild_index(self, documents: List[Document], force_rebuild: bool = False, use_openai: bool = True) -> bool:
+        """인덱스 재구축"""
+        if force_rebuild:
+            print("🔄 기존 데이터 삭제 후 재구축...")
+            self.delete_all_documents()
+
+        return self.add_documents(documents, use_openai)
+
+# 테스트용 함수
+def test_supabase_vector_store():
+    """Supabase 벡터 데이터베이스 테스트"""
+    from document_processor import DocumentProcessor
+
+    # 문서 처리
+    processor = DocumentProcessor()
+    documents = processor.load_documents_from_folder("documents")
+
+    if not documents:
+        print("⚠️ 테스트할 문서가 없습니다.")
+        return
+
+    # 벡터 데이터베이스 생성
+    vector_store = SupabaseVectorStore()
+
+    # 문서 추가
+    success = vector_store.add_documents(documents[:5])  # 테스트용으로 5개만
+    if not success:
+        print("❌ 문서 추가 실패")
+        return
+
+    # 검색 테스트
+    test_queries = [
+        "연차휴가 사용 방법",
+        "근무시간은 어떻게 되나요?",
+        "당직근무 절차"
+    ]
+
+    for query in test_queries:
+        print(f"\n🔍 검색: {query}")
+        results = vector_store.search_similar(query, k=3)
+
+        for i, (doc, similarity) in enumerate(results):
+            print(f"  {i+1}. 유사도: {similarity:.4f}")
+            print(f"     내용: {doc.page_content[:100]}...")
+
+if __name__ == "__main__":
+    test_supabase_vector_store()

vector_store.py

@@ -5,7 +5,7 @@ from typing import List, Dict, Tuple
 from pathlib import Path
 from sentence_transformers import SentenceTransformer
 import faiss
-from langchain.schema import Document
+from langchain_core.documents import Document
 from config import Config
 
 class VectorStore: