feat: Add Re-ranking system and improve AI response prompts

- Add vector DB (Chroma) integration

- Implement vector search and Cross-Encoder re-ranking

- Add prompts for citing sources in AI responses

- Add prompt to say 'Content not found' when no evidence exists

- Update requirements.txt with sentence-transformers and chromadb

app/routes.py

@@ -2,6 +2,7 @@ from flask import Blueprint, render_template, request, jsonify, send_from_direct
 from flask_login import login_user, logout_user, login_required, current_user
 from werkzeug.utils import secure_filename
 from app.database import db, UploadedFile, User, ChatSession, ChatMessage, DocumentChunk, ParentChunk
+from app.vector_db import get_vector_db
 import requests
 import os
 from datetime import datetime
@@ -177,15 +178,21 @@ def split_text_into_chunks(text, min_chunk_size=200, max_chunk_size=1000, overla
     return final_chunks if final_chunks else [text] if text.strip() else []
 
 def create_chunks_for_file(file_id, content):
-    """파일 내용을 의미 기반 청크로 분할하여 저장"""
+    """파일 내용을 의미 기반 청크로 분할하여 저장 (벡터 DB 포함)"""
     try:
         print(f"[청크 생성] 파일 ID {file_id}에 대한 청크 생성 시작")
         print(f"[청크 생성] 원본 텍스트 길이: {len(content)}자")
         
-        # 기존 청크 삭제
-        existing_chunks = DocumentChunk.query.filter_by(file_id=file_id).count()
-        if existing_chunks > 0:
-            print(f"[청크 생성] 기존 청크 {existing_chunks}개 삭제")
+        # 벡터 DB 매니저 가져오기
+        vector_db = get_vector_db()
+        
+        # 기존 청크 삭제 (DB + 벡터 DB)
+        existing_chunks = DocumentChunk.query.filter_by(file_id=file_id).all()
+        if existing_chunks:
+            print(f"[청크 생성] 기존 청크 {len(existing_chunks)}개 삭제 중...")
+            # 벡터 DB에서 삭제
+            vector_db.delete_chunks_by_file_id(file_id)
+            # DB에서 삭제
             DocumentChunk.query.filter_by(file_id=file_id).delete()
             db.session.commit()
         
@@ -198,27 +205,40 @@ def create_chunks_for_file(file_id, content):
             print(f"[청크 생성] 경고: 청크가 생성되지 않았습니다. 텍스트가 너무 짧거나 비어있을 수 있습니다.")
             return 0
         
-        # 각 청크를 데이터베이스에 저장
+        # 각 청크를 데이터베이스와 벡터 DB에 저장
         saved_count = 0
+        vector_saved_count = 0
         for idx, chunk_content in enumerate(chunks):
             try:
+                # DB에 청크 저장
                 chunk = DocumentChunk(
                     file_id=file_id,
                     chunk_index=idx,
                     content=chunk_content
                 )
                 db.session.add(chunk)
+                db.session.flush()  # ID 생성
+                
+                # 벡터 DB에 청크 추가
+                if vector_db.add_chunk(
+                    chunk_id=chunk.id,
+                    chunk_content=chunk_content,
+                    file_id=file_id,
+                    chunk_index=idx
+                ):
+                    vector_saved_count += 1
+                
                 saved_count += 1
                 
                 # 진행 상황 출력 (10개마다)
                 if (idx + 1) % 10 == 0:
-                    print(f"[청크 생성] 진행 중: {idx + 1}/{len(chunks)}개 청크 저장 중...")
+                    print(f"[청크 생성] 진행 중: {idx + 1}/{len(chunks)}개 청크 저장 중... (DB: {saved_count}, 벡터 DB: {vector_saved_count})")
             except Exception as e:
                 print(f"[청크 생성] 경고: 청크 {idx} 저장 중 오류: {str(e)}")
                 continue
         
         db.session.commit()
-        print(f"[청크 생성] 완료: {saved_count}개 청크가 데이터베이스에 저장되었습니다.")
+        print(f"[청크 생성] 완료: {saved_count}개 청크가 데이터베이스에 저장되었습니다. (벡터 DB: {vector_saved_count}개)")
         
         # 저장 확인
         verified_count = DocumentChunk.query.filter_by(file_id=file_id).count()
@@ -440,8 +460,86 @@ def get_parent_chunks_for_files(file_ids):
         print(f"[Parent Chunk 조회] 오류: {str(e)}")
         return []
 
-def search_relevant_chunks(query, file_ids=None, model_name=None, top_k=25, min_score=1):
-    """질문과 관련된 청크 검색 (개선된 키워드 기반 검색) - Child Chunk 정밀 검색"""
+def search_relevant_chunks(query, file_ids=None, model_name=None, top_k=5, min_score=1):
+    """
+    질문과 관련된 청크 검색 (벡터 검색 + Re-ranking)
+    1. 벡터 검색으로 초기 30개 문서 검색
+    2. Cross-Encoder로 리랭킹
+    3. 상위 top_k개 반환 (기본 5개)
+    """
+    try:
+        # 벡터 DB 매니저 가져오기
+        vector_db = get_vector_db()
+        
+        # 파일 ID 확장 (이어서 업로드된 파일 포함)
+        expanded_file_ids = None
+        if file_ids:
+            expanded_file_ids = list(file_ids)
+            for file_id in file_ids:
+                # 원본 파일인 경우 이어서 업로드된 파일들도 포함
+                child_files = UploadedFile.query.filter_by(parent_file_id=file_id).all()
+                expanded_file_ids.extend([child.id for child in child_files])
+            
+            # 원본 파일이 선택된 경우, 이어서 업로드된 파일들도 포함
+            parent_files = UploadedFile.query.filter(UploadedFile.id.in_(file_ids), UploadedFile.parent_file_id.is_(None)).all()
+            for parent_file in parent_files:
+                child_files = UploadedFile.query.filter_by(parent_file_id=parent_file.id).all()
+                expanded_file_ids.extend([child.id for child in child_files])
+        
+        # 모델 필터링이 필요한 경우 파일 ID 필터링
+        if model_name and expanded_file_ids:
+            filtered_files = UploadedFile.query.filter(
+                UploadedFile.id.in_(expanded_file_ids),
+                UploadedFile.model_name == model_name
+            ).all()
+            expanded_file_ids = [f.id for f in filtered_files]
+        elif model_name and not expanded_file_ids:
+            # 파일 ID가 없으면 모델 이름으로만 필터링
+            filtered_files = UploadedFile.query.filter_by(model_name=model_name).all()
+            expanded_file_ids = [f.id for f in filtered_files]
+        
+        # 1단계: 벡터 검색으로 초기 30개 문서 검색
+        print(f"[벡터 검색] 쿼리: {query[:50]}..., 파일 ID: {expanded_file_ids if expanded_file_ids else '모든 파일'}")
+        vector_results = vector_db.search_chunks(
+            query=query,
+            file_ids=expanded_file_ids,
+            top_k=30
+        )
+        
+        if not vector_results:
+            print(f"[벡터 검색] 결과 없음, 키워드 기반 검색으로 대체")
+            # 벡터 검색 결과가 없으면 기존 키워드 기반 검색으로 대체
+            return search_relevant_chunks_fallback(query, file_ids, model_name, top_k, min_score)
+        
+        # 2단계: Cross-Encoder로 리랭킹
+        print(f"[리랭킹] {len(vector_results)}개 청크에 대한 리랭킹 시작...")
+        reranked_chunks = vector_db.rerank_chunks(
+            query=query,
+            chunks=vector_results,
+            top_k=top_k
+        )
+        
+        # 3단계: DB에서 청크 객체 가져오기
+        final_chunks = []
+        for reranked in reranked_chunks:
+            chunk_id = reranked['chunk_id']
+            chunk = DocumentChunk.query.get(chunk_id)
+            if chunk:
+                final_chunks.append(chunk)
+        
+        print(f"[벡터 검색 + 리랭킹] 최종 {len(final_chunks)}개 청크 반환")
+        return final_chunks
+        
+    except Exception as e:
+        print(f"[벡터 검색] 오류: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        # 오류 시 기존 키워드 기반 검색으로 대체
+        print(f"[벡터 검색] 키워드 기반 검색으로 대체")
+        return search_relevant_chunks_fallback(query, file_ids, model_name, top_k, min_score)
+
+def search_relevant_chunks_fallback(query, file_ids=None, model_name=None, top_k=25, min_score=1):
+    """기존 키워드 기반 검색 (Fallback)"""
     try:
         # 검색 쿼리 준비 - 한글과 영문 단어 모두 추출
         query_words = set(re.findall(r'[가-힣]+|\w+', query.lower()))
@@ -507,21 +605,12 @@ def search_relevant_chunks(query, file_ids=None, model_name=None, top_k=25, min_
         # 점수 순으로 정렬하고 상위 k개 선택
         scored_chunks.sort(key=lambda x: x[0], reverse=True)
         
-        # top_k개 선택하되, 점수가 비슷한 청크도 포함 (점수 차이가 30% 이내면 포함)
-        top_chunks = []
-        if scored_chunks:
-            max_score = scored_chunks[0][0]
-            threshold = max_score * 0.7  # 최고 점수의 70% 이상인 청크도 포함
-            
-            for score, chunk in scored_chunks:
-                if len(top_chunks) < top_k or score >= threshold:
-                    top_chunks.append(chunk)
-                else:
-                    break
+        # top_k개 선택
+        top_chunks = [chunk for score, chunk in scored_chunks[:top_k]]
         
         return top_chunks
     except Exception as e:
-        print(f"청크 검색 오류: {str(e)}")
+        print(f"[키워드 검색] 오류: {str(e)}")
         import traceback
         traceback.print_exc()
         return []
@@ -813,16 +902,16 @@ def chat():
                         parent_chunks = get_parent_chunks_for_files(file_ids)
                         print(f"[RAG 검색 1단계] Parent Chunk 조회 완료: {len(parent_chunks)}개 파일")
                     
-                    # 2단계: Child Chunk로 정밀 검색
-                    print(f"[RAG 검색 2단계] Child Chunk 정밀 검색 시작...")
+                    # 2단계: 벡터 검색 + 리랭킹으로 Child Chunk 정밀 검색
+                    print(f"[RAG 검색 2단계] 벡터 검색 + 리랭킹 시작...")
                     relevant_chunks = search_relevant_chunks(
                         query=message,
                         file_ids=file_ids if file_ids else None,
                         model_name=model,
-                        top_k=25,  # 25개 청크 검색
+                        top_k=5,  # 리랭킹 후 상위 5개만 선택
                         min_score=0.5  # 최소 점수 임계값
                     )
-                    print(f"[RAG 검색 2단계] Child Chunk 검색 완료: {len(relevant_chunks)}개 청크")
+                    print(f"[RAG 검색 2단계] 벡터 검색 + 리랭킹 완료: {len(relevant_chunks)}개 청크 (상위 5개)")
                     
                     # 컨텍스트 구성
                     context_parts = []
@@ -902,6 +991,10 @@ def chat():
 - 그 다음 구체적인 내용(Child Chunk)을 통해 질문에 대한 정확한 답변을 제공하세요.
 - 웹소설의 맥락과 스토리를 고려하여 일관성 있는 답변을 작성하세요.
 
+중요: 질문에 답변할 때는 반드시 제공된 [소설 본문] 내의 내용을 근거로 해야 합니다.
+답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
+근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
+
 질문:
 """
                         elif parent_chunks:
@@ -912,6 +1005,10 @@ def chat():
 
 위 정보를 참고하여 질문에 답변해주세요. 웹소설의 배경과 설정을 고려하여 답변하세요.
 
+중요: 질문에 답변할 때는 반드시 제공된 [소설 본문] 내의 내용을 근거로 해야 합니다.
+답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
+근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
+
 질문:
 """
                         else:
@@ -920,7 +1017,11 @@ def chat():
 
 {full_context}
 
-위 내용을 충분히 참고하여 다음 질문에 정확하고 상세하게 답변해주세요. 웹소설의 맥락과 스토리를 고려하여 답변해주세요:
+위 내용을 충분히 참고하여 다음 질문에 정확하고 상세하게 답변해주세요. 웹소설의 맥락과 스토리를 고려하여 답변해주세요.
+
+중요: 질문에 답변할 때는 반드시 제공된 [소설 본문] 내의 내용을 근거로 해야 합니다.
+답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
+근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
 
 질문:
 """
@@ -981,7 +1082,18 @@ def chat():
                         
                         if context_parts:
                             context = "\n\n".join(context_parts)
-                            context = f"다음은 학습된 웹소설 내용입니다:\n\n{context}\n\n위 내용을 참고하여 다음 질문에 답변해주세요:\n\n"
+                            context = f"""다음은 학습된 웹소설 내용입니다:
+
+{context}
+
+위 내용을 참고하여 다음 질문에 답변해주세요.
+
+중요: 질문에 답변할 때는 반드시 제공된 [소설 본문] 내의 내용을 근거로 해야 합니다.
+답변의 각 문장 끝에는 참고한 본문의 문장을 [근거: "문장 내용..."] 형식으로 반드시 붙이세요.
+근거를 찾을 수 없다면 "내용을 찾을 수 없습니다"라고 답하고 지어내지 마세요.
+
+질문:
+"""
                 
                 # 프롬프트 구성
                 full_prompt = context + message if context else message
@@ -1567,6 +1679,14 @@ def delete_file(file_id):
                     DocumentChunk.query.filter_by(file_id=file_to_delete.id).delete()
                     print(f"[파일 삭제] Child Chunk {child_chunk_count}개 삭제 완료")
                 
+                # 벡터 DB에서도 해당 파일의 청크 삭제
+                try:
+                    vector_db = get_vector_db()
+                    vector_db.delete_chunks_by_file_id(file_to_delete.id)
+                    print(f"[파일 삭제] 벡터 DB에서 청크 삭제 완료")
+                except Exception as vector_e:
+                    print(f"[파일 삭제] 벡터 DB 삭제 오류 (무시): {str(vector_e)}")
+                
                 # 관련 Parent Chunk 삭제
                 parent_chunk = ParentChunk.query.filter_by(file_id=file_to_delete.id).first()
                 if parent_chunk:

app/vector_db.py

@@ -0,0 +1,281 @@
+"""
+벡터 DB 및 임베딩 관련 기능
+Chroma DB를 사용한 벡터 검색 및 Re-ranking 시스템
+"""
+
+import os
+import json
+import chromadb
+from chromadb.config import Settings
+from sentence_transformers import SentenceTransformer, CrossEncoder
+from pathlib import Path
+import numpy as np
+
+# 벡터 DB 경로
+VECTOR_DB_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'vector_db')
+
+# 임베딩 모델 (한국어 지원)
+EMBEDDING_MODEL_NAME = "jhgan/ko-sroberta-multitask"  # 한국어 지원 모델
+# 또는 영어 중심: "all-MiniLM-L6-v2" (더 빠르지만 한국어 성능 낮음)
+
+# Cross-Encoder 모델 (리랭킹용)
+# 한국어 리랭커를 찾을 수 없으면 영어 모델 사용
+RERANKER_MODEL_NAME = "cross-encoder/ms-marco-MiniLM-L-6-v2"  # 범용 리랭커 (한국어도 어느 정도 지원)
+# 또는: "BAAI/bge-reranker-base" (더 나은 성능)
+
+class VectorDBManager:
+    """벡터 DB 관리 클래스"""
+    
+    def __init__(self):
+        """벡터 DB 초기화"""
+        self.embedding_model = None
+        self.reranker_model = None
+        self.client = None
+        self.collection = None
+        
+        # 벡터 DB 폴더 생성
+        os.makedirs(VECTOR_DB_PATH, exist_ok=True)
+        
+        # Chroma DB 클라이언트 초기화
+        self.client = chromadb.PersistentClient(
+            path=VECTOR_DB_PATH,
+            settings=Settings(
+                anonymized_telemetry=False,
+                allow_reset=True
+            )
+        )
+        
+        # 컬렉션 생성 (없으면 생성, 있으면 가져오기)
+        try:
+            self.collection = self.client.get_or_create_collection(
+                name="document_chunks",
+                metadata={"hnsw:space": "cosine"}  # 코사인 유사도 사용
+            )
+            print(f"[벡터 DB] 컬렉션 로드/생성 완료: {len(self.collection.get()['ids'])}개 문서")
+        except Exception as e:
+            print(f"[벡터 DB] 컬렉션 생성 오류: {e}")
+            raise
+    
+    def get_embedding_model(self):
+        """임베딩 모델 로드 (지연 로딩)"""
+        if self.embedding_model is None:
+            print(f"[임베딩 모델] 로딩 중: {EMBEDDING_MODEL_NAME}")
+            try:
+                self.embedding_model = SentenceTransformer(EMBEDDING_MODEL_NAME)
+                print(f"[임베딩 모델] 로딩 완료")
+            except Exception as e:
+                print(f"[임베딩 모델] 로딩 오류: {e}")
+                # 대체 모델 시도
+                try:
+                    self.embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
+                    print(f"[임베딩 모델] 대체 모델 로딩 완료: all-MiniLM-L6-v2")
+                except Exception as e2:
+                    print(f"[임베딩 모델] 대체 모델도 로딩 실패: {e2}")
+                    raise
+        return self.embedding_model
+    
+    def get_reranker_model(self):
+        """Cross-Encoder 리랭커 모델 로드 (지연 로딩)"""
+        if self.reranker_model is None:
+            print(f"[리랭커 모델] 로딩 중: {RERANKER_MODEL_NAME}")
+            try:
+                self.reranker_model = CrossEncoder(RERANKER_MODEL_NAME)
+                print(f"[리랭커 모델] 로딩 완료")
+            except Exception as e:
+                print(f"[리랭커 모델] 로딩 오류: {e}")
+                # 대체 모델 시도 (더 가벼운 모델)
+                try:
+                    print(f"[리랭커 모델] 대체 모델 시도: BAAI/bge-reranker-base")
+                    self.reranker_model = CrossEncoder("BAAI/bge-reranker-base", max_length=512)
+                    print(f"[리랭커 모델] 대체 모델 로딩 완료")
+                except Exception as e2:
+                    print(f"[리랭커 모델] 대체 모델도 로딩 실패: {e2}")
+                    # 리랭킹 없이 진행 (경고만 출력)
+                    print(f"[리랭커 모델] ⚠️ 경고: 리랭커 모델을 로드할 수 없습니다. 리랭킹 없이 진행합니다.")
+                    self.reranker_model = None
+        return self.reranker_model
+    
+    def generate_embedding(self, text):
+        """텍스트에 대한 임베딩 생성"""
+        try:
+            model = self.get_embedding_model()
+            embedding = model.encode(text, convert_to_numpy=True).tolist()
+            return embedding
+        except Exception as e:
+            print(f"[임베딩 생성] 오류: {e}")
+            return None
+    
+    def add_chunk(self, chunk_id, chunk_content, file_id, chunk_index, metadata=None):
+        """청크를 벡터 DB에 추가"""
+        try:
+            # 임베딩 생성
+            embedding = self.generate_embedding(chunk_content)
+            if embedding is None:
+                return False
+            
+            # 메타데이터 준비
+            chunk_metadata = {
+                'file_id': str(file_id),
+                'chunk_index': str(chunk_index),
+                'content_length': str(len(chunk_content))
+            }
+            if metadata:
+                chunk_metadata.update(metadata)
+            
+            # 벡터 DB에 추가
+            self.collection.add(
+                ids=[str(chunk_id)],
+                embeddings=[embedding],
+                documents=[chunk_content],
+                metadatas=[chunk_metadata]
+            )
+            
+            return True
+        except Exception as e:
+            print(f"[벡터 DB 추가] 오류: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+    
+    def search_chunks(self, query, file_ids=None, top_k=30):
+        """벡터 검색으로 관련 청크 검색 (초기 검색, top_k=30)"""
+        try:
+            # 쿼리 임베딩 생성
+            query_embedding = self.generate_embedding(query)
+            if query_embedding is None:
+                return []
+            
+            # 필터 조건 설정
+            where_clause = None
+            if file_ids:
+                where_clause = {"file_id": {"$in": [str(fid) for fid in file_ids]}}
+            
+            # 벡터 검색
+            results = self.collection.query(
+                query_embeddings=[query_embedding],
+                n_results=min(top_k, 30),  # 최대 30개
+                where=where_clause
+            )
+            
+            # 결과 파싱
+            chunks = []
+            if results and 'ids' in results and len(results['ids'][0]) > 0:
+                for i, chunk_id in enumerate(results['ids'][0]):
+                    chunks.append({
+                        'chunk_id': int(chunk_id),
+                        'content': results['documents'][0][i] if 'documents' in results else '',
+                        'metadata': results['metadatas'][0][i] if 'metadatas' in results else {},
+                        'distance': results['distances'][0][i] if 'distances' in results else 1.0
+                    })
+            
+            print(f"[벡터 검색] {len(chunks)}개 청크 검색 완료")
+            return chunks
+        except Exception as e:
+            print(f"[벡터 검색] 오류: {e}")
+            import traceback
+            traceback.print_exc()
+            return []
+    
+    def rerank_chunks(self, query, chunks, top_k=5):
+        """Cross-Encoder를 사용하여 청크 리랭킹 (상위 top_k개 반환)"""
+        try:
+            if not chunks or len(chunks) == 0:
+                return []
+            
+            # 리랭커 모델 로드
+            reranker = self.get_reranker_model()
+            
+            # 리랭커 모델이 없으면 거리 기반 정렬만 수행
+            if reranker is None:
+                print(f"[리랭킹] ⚠️ 리랭커 모델 없음, 거리 기반 정렬만 수행")
+                scored_chunks = []
+                for chunk in chunks:
+                    scored_chunks.append({
+                        'chunk_id': chunk['chunk_id'],
+                        'content': chunk['content'],
+                        'metadata': chunk['metadata'],
+                        'rerank_score': 1.0 - chunk.get('distance', 1.0),  # 거리를 점수로 변환
+                        'original_distance': chunk.get('distance', 1.0)
+                    })
+                scored_chunks.sort(key=lambda x: x['rerank_score'], reverse=True)
+                return scored_chunks[:top_k]
+            
+            # 쿼리-문서 쌍 준비 (최대 길이 제한)
+            pairs = []
+            max_content_length = 500  # 청크 내용이 너무 길면 잘라냄
+            for chunk in chunks:
+                content = chunk['content']
+                if len(content) > max_content_length:
+                    content = content[:max_content_length]
+                pairs.append([query, content])
+            
+            # 리랭킹 점수 계산
+            print(f"[리랭킹] {len(pairs)}개 청크에 대한 리랭킹 시작...")
+            scores = reranker.predict(pairs)
+            
+            # 점수와 청크 결합
+            scored_chunks = []
+            for i, chunk in enumerate(chunks):
+                scored_chunks.append({
+                    'chunk_id': chunk['chunk_id'],
+                    'content': chunk['content'],
+                    'metadata': chunk['metadata'],
+                    'rerank_score': float(scores[i]),
+                    'original_distance': chunk.get('distance', 1.0)
+                })
+            
+            # 점수 순으로 정렬 (높은 점수 = 더 관련성 높음)
+            scored_chunks.sort(key=lambda x: x['rerank_score'], reverse=True)
+            
+            # 상위 top_k개만 선택
+            top_chunks = scored_chunks[:top_k]
+            
+            print(f"[리랭킹] 완료: 상위 {len(top_chunks)}개 청크 선택")
+            for i, chunk in enumerate(top_chunks):
+                print(f"  {i+1}. 점수: {chunk['rerank_score']:.4f}, 청크 ID: {chunk['chunk_id']}")
+            
+            return top_chunks
+        except Exception as e:
+            print(f"[리랭킹] 오류: {e}")
+            import traceback
+            traceback.print_exc()
+            # 오류 시 원본 청크 상위 top_k개 반환 (거리 기준)
+            chunks_sorted = sorted(chunks, key=lambda x: x.get('distance', 1.0))
+            return chunks_sorted[:top_k]
+    
+    def delete_chunks_by_file_id(self, file_id):
+        """파일 ID로 해당 파일의 모든 청크 삭제"""
+        try:
+            # 해당 파일의 모든 청크 찾기
+            results = self.collection.get(
+                where={"file_id": str(file_id)}
+            )
+            
+            if results and 'ids' in results and len(results['ids']) > 0:
+                # 청크 삭제
+                self.collection.delete(ids=results['ids'])
+                print(f"[벡터 DB 삭제] 파일 ID {file_id}의 {len(results['ids'])}개 청크 삭제 완료")
+                return True
+            return False
+        except Exception as e:
+            print(f"[벡터 DB 삭제] 오류: {e}")
+            return False
+    
+    def get_chunk_count(self):
+        """벡터 DB에 저장된 청크 개수 반환"""
+        try:
+            return self.collection.count()
+        except Exception as e:
+            print(f"[벡터 DB] 청크 개수 조회 오류: {e}")
+            return 0
+
+# 전역 벡터 DB 매니저 인스턴스
+_vector_db_manager = None
+
+def get_vector_db():
+    """벡터 DB 매니저 싱글톤 인스턴스 반환"""
+    global _vector_db_manager
+    if _vector_db_manager is None:
+        _vector_db_manager = VectorDBManager()
+    return _vector_db_manager
+

requirements.txt

@@ -4,5 +4,8 @@ flask-login==0.6.3
 python-dotenv==1.0.0
 requests==2.31.0
 werkzeug==3.0.1
+chromadb==0.4.22
+sentence-transformers==2.3.1
+numpy==1.24.3