Add application file

app/app.py

@@ -1,4 +1,201 @@
-"""
+@app.route('/api/upload', methods=['POST'])
+@login_required
+def upload_document():
+    """지식베이스 문서 업로드 API"""
+    global base_retriever, retriever, app_ready
+    
+    # 앱 준비 상태 확인
+    if not app_ready:
+        return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+    
+    try:
+        # 파일이 요청에 포함되어 있는지 확인
+        if 'document' not in request.files:
+            return jsonify({"error": "문서 파일이 제공되지 않았습니다."}), 400
+        
+        doc_file = request.files['document']
+        logger.info(f"받은 파일명: {doc_file.filename}")
+        
+        # 파일명이 비어있는지 확인
+        if doc_file.filename == '':
+            return jsonify({"error": "선택된 파일이 없습니다."}), 400
+        
+        # 파일 형식 확인
+        if not allowed_doc_file(doc_file.filename):
+            logger.error(f"허용되지 않는 파일 형식: {doc_file.filename}")
+            return jsonify({"error": "허용되지 않는 파일 형식입니다. 현재 허용된 파일 형식: {}".format(', '.join(ALLOWED_DOC_EXTENSIONS))}), 400
+        
+        # 파일명 보안 처리
+        filename = secure_filename(doc_file.filename)
+        
+        # 데이터 폴더에 저장
+        filepath = os.path.join(app.config['DATA_FOLDER'], filename)
+        doc_file.save(filepath)
+        
+        logger.info(f"문서가 저장되었습니다: {filepath}")
+        
+        # 문서 처리
+        try:
+            # 먼저 UTF-8로 시도
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    content = f.read()
+            except UnicodeDecodeError:
+                # UTF-8로 실패하면 CP949(한국어 Windows 기본 인코딩)로 시도
+                logger.info(f"UTF-8 디코딩 실패, CP949로 시도: {filename}")
+                with open(filepath, 'r', encoding='cp949') as f:
+                    content = f.read()
+            
+            # 메타데이터 생성
+            metadata = {
+                "source": filename,
+                "filename": filename,
+                "filetype": filename.rsplit('.', 1)[1].lower(),
+                "filepath": filepath
+            }
+            
+            # 파일 형식에 따라 다른 처리 적용
+            file_ext = filename.rsplit('.', 1)[1].lower()
+            
+            # CSV 파일은 행 단위로 처리
+            if file_ext == 'csv':
+                logger.info(f"CSV 파일 업로드 감지, 행 단위로 분할 처리: {filename}")
+                docs = DocumentProcessor.csv_to_documents(content, metadata)
+            else:
+                # 일반 텍스트 문서 처리
+                docs = DocumentProcessor.text_to_documents(
+                    content,
+                    metadata=metadata,
+                    chunk_size=512,
+                    chunk_overlap=50
+                )
+            
+            if docs:
+                logger.info(f"{len(docs)}개 문서 청크를 검색기에 추가합니다...")
+                base_retriever.add_documents(docs)
+                
+                # 인덱스 저장
+                logger.info(f"검색기 상태를 저장합니다...")
+                index_path = app.config['INDEX_PATH']
+                try:
+                    base_retriever.save(index_path)
+                    logger.info("인덱스 저장 완료")
+                except Exception as e:
+                    logger.error(f"인덱스 저장 중 오류 발생: {e}")
+                    return jsonify({"error": f"인덱스 저장 중 오류: {str(e)}"}), 500
+                
+                return jsonify({
+                    "success": True,
+                    "message": f"파일 '{filename}'가 성공적으로 업로드되고 {len(docs)}개 청크가 추가되었습니다."
+                })
+            else:
+                logger.warning(f"파일 '{filename}'에서 처리할 문서가 없습니다.")
+                return jsonify({
+                    "warning": True,
+                    "message": f"파일 '{filename}'이 저장되었지만 처리할 내용이 없습니다."
+                })
+                
+        except Exception as e:
+            logger.error(f"문서 '{filename}' 처리 중 오류 발생: {e}", exc_info=True)
+            return jsonify({"error": f"문서 처리 중 오류: {str(e)}"}), 500
+        
+    except Exception as e:
+        logger.error(f"파일 업로드 중 오류 발생: {e}", exc_info=True)
+        return jsonify({"error": f"파일 업로드 중 오류: {str(e)}"}), 500
+
+@app.route('/api/documents', methods=['GET'])
+@login_required
+def list_documents():
+    """지식베이스 문서 목록 API"""
+    global base_retriever, retriever, app_ready
+    
+    # 앱 준비 상태 확인
+    if not app_ready:
+        return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 ��� 다시 시도해주세요."}), 503
+    
+    try:
+        # 문서 소스 목록 생성
+        sources = {}
+        
+        if base_retriever and base_retriever.documents:
+            for doc in base_retriever.documents:
+                source = doc.get("source", "unknown")
+                if source in sources:
+                    sources[source]["chunks"] += 1
+                else:
+                    sources[source] = {
+                        "filename": doc.get("filename", source),
+                        "chunks": 1,
+                        "filetype": doc.get("filetype", "unknown")
+                    }
+        
+        # 목록 형식으로 변환
+        documents = []
+        for source, info in sources.items():
+            documents.append({
+                "source": source,
+                "filename": info["filename"],
+                "chunks": info["chunks"],
+                "filetype": info["filetype"]
+            })
+        
+        # 청크 수로 정렬
+        documents.sort(key=lambda x: x["chunks"], reverse=True)
+        
+        return jsonify({
+            "documents": documents,
+            "total_documents": len(documents),
+            "total_chunks": sum(doc["chunks"] for doc in documents)
+        })
+        
+    except Exception as e:
+        logger.error(f"문서 목록 조회 중 오류 발생: {e}", exc_info=True)
+        return jsonify({"error": f"문서 목록 조회 중 오류: {str(e)}"}), 500
+
+# 정적 파일 서빙
+@app.route('/static/<path:path>')
+def send_static(path):
+    return send_from_directory('static', path)# 세션 쿠키 처리 확인 및 수정
+@app.before_request
+def process_cookies():
+    # 수동 쿠키 처리 확인
+    if 'session_data' in request.cookies and 'logged_in' not in session:
+        try:
+            cookie_data = json.loads(request.cookies.get('session_data'))
+            logger.info(f"\n[Before Request] 수동 쿠키 값 발견: {cookie_data}")
+            if cookie_data.get('logged_in'):
+                # 세션 재구성
+                session['logged_in'] = True
+                session['username'] = cookie_data.get('username')
+                logger.info(f"\n[Before Request] 수동 쿠키에서 세션 복원: {session}")
+        except Exception as e:
+            logger.error(f"\n[Before Request] 쿠키 처리 오류: {e}")# 허깅페이스 환경을 위한 세션 처리 향상
+@app.after_request
+def after_request_func(response):
+    # 세션이 수정되었는지 확인
+    if session.modified:
+        logger.info("\n[After Request] 세션이 수정되었습니다.")
+        logger.info(f"\ud604재 세션 내용: {session}")
+        
+    # 응답 헤더 로깅
+    logger.info("\n[Response Headers]")
+    for header, value in response.headers:
+        logger.info(f"  {header}: {value}")
+    
+    # 쿠키 설정
+    if 'Set-Cookie' in response.headers:
+        logger.info(f"Set-Cookie 헤더 있음: {response.headers['Set-Cookie']}")
+    else:
+        # 로그인 후 세션 쿠키가 없으면 세션 값을 확인
+        if 'logged_in' in session and request.path != '/login':
+            logger.info("세션에 logged_in이 있지만 쿠키가 설정되지 않았습니다.")
+    
+    # 허깅페이스 프록시 관련 헤더 처리
+    response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
+    response.headers['Pragma'] = 'no-cache'
+    response.headers['Expires'] = '0'
+    
+    return response"""
 RAG 검색 챗봇 웹 애플리케이션
 """
 
@@ -23,6 +220,23 @@ logger = logging.getLogger(__name__)
 # 환경 변수 로드
 load_dotenv()
 
+# 환경 변수 로드 상태 확인 및 로깅
+ADMIN_USERNAME = os.getenv('ADMIN_USERNAME')
+ADMIN_PASSWORD = os.getenv('ADMIN_PASSWORD')
+
+logger.info(f"==== 환경 변수 로드 상태 ====")
+logger.info(f"ADMIN_USERNAME 설정 여부: {ADMIN_USERNAME is not None}")
+logger.info(f"ADMIN_PASSWORD 설정 여부: {ADMIN_PASSWORD is not None}")
+
+# 환경 변수가 없으면 기본값 설정
+if not ADMIN_USERNAME:
+    ADMIN_USERNAME = 'admin'
+    logger.warning("ADMIN_USERNAME 환경변수가 없어 기본값 'admin'으로 설정합니다.")
+
+if not ADMIN_PASSWORD:
+    ADMIN_PASSWORD = 'rag12345'
+    logger.warning("ADMIN_PASSWORD 환경변수가 없어 기본값 'rag12345'로 설정합니다.")
+
 # 로컬 모듈 임포트
 from utils.vito_stt import VitoSTT
 from utils.llm_interface import LLMInterface
@@ -36,11 +250,13 @@ app = Flask(__name__)
 # 세션 설정 - 고정된 시크릿 키 사용
 app.secret_key = 'rag_chatbot_fixed_secret_key_12345'  # 고정된 시크릿 키
 
-# 세션 설정 추가
-app.config['SESSION_COOKIE_SECURE'] = False  # HTTPS에서만 쿠키 전송 (False로 설정하여 HTTP에서도 세션 사용 가능)
+# 세션 설정 추가 - 허깅페이스 환경에 맞게 조정
+app.config['SESSION_COOKIE_SECURE'] = False  # HTTP 에서도 쿠키 전송 가능
 app.config['SESSION_COOKIE_HTTPONLY'] = True  # JavaScript에서 쿠키 접근 방지
-app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'  # CSRF 방지
-app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(hours=5)  # 세션 유효 시간
+app.config['SESSION_COOKIE_SAMESITE'] = None  # 허깅페이스 프로시 관련 이슈 수정
+app.config['SESSION_COOKIE_DOMAIN'] = None  # 모든 도메인에 쿠키 적용
+app.config['SESSION_COOKIE_PATH'] = '/'  # 모든 경로에 쿠키 적용
+app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=1)  # 세션 유효 시간 증가
 
 # 최대 파일 크기 설정 (10MB)
 app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
@@ -80,7 +296,19 @@ def login_required(f):
         logger.info(f"현재 세션 객체: {session}")
         logger.info(f"현재 세션 상태: logged_in={session.get('logged_in', False)}, username={session.get('username', 'None')}")
         logger.info(f"현재 세션 케이: {request.cookies.get('session', 'None')}")
-        if 'logged_in' not in session:
+        
+        # 수동 쿠키 확인
+        has_manual_cookie = False
+        if 'session_data' in request.cookies:
+            try:
+                cookie_data = json.loads(request.cookies.get('session_data'))
+                logger.info(f"수동 쿠키 데이터: {cookie_data}")
+                has_manual_cookie = cookie_data.get('logged_in', False)
+            except:
+                pass
+        
+        # 세션 또는 수동 쿠키 중 하나라도 있으면 인증 성공
+        if 'logged_in' not in session and not has_manual_cookie:
             logger.warning(f"비로그인 상태에서 {request.path} 접근 시도, 로그인 페이지로 리디렉션")
             return redirect(url_for('login'))
         
@@ -204,6 +432,16 @@ def login():
     logger.info("-------------- 로그인 페이지 접속 --------------")
     logger.info(f"Method: {request.method}")
     
+    # 경로 로그 추가
+    logger.info(f"Request Path: {request.path}")
+    logger.info(f"Request Host: {request.host}")
+    logger.info(f"Request URL: {request.url}")
+    
+    # 모든 헤더 로그
+    logger.info("Request Headers:")
+    for header, value in request.headers.items():
+        logger.info(f"  {header}: {value}")
+    
     if request.method == 'POST':
         logger.info("로그인 시도 받음")
         
@@ -214,13 +452,27 @@ def login():
         # 비밀번호는 일부 검출 후 로깅
         logger.info(f"비밀번호 입력 여부: {len(password) > 0}")
         
-        # .env에서 계정 정보 가져오기
-        valid_username = os.getenv('ADMIN_USERNAME')
-        valid_password = os.getenv('ADMIN_PASSWORD')
+        # 허깅페이스 환경변수 직접 확인
+        # .env에서 가져오기
+        valid_username = os.environ.get('ADMIN_USERNAME') or os.getenv('ADMIN_USERNAME')
+        valid_password = os.environ.get('ADMIN_PASSWORD') or os.getenv('ADMIN_PASSWORD')
+        
+        # 환경변수 디버깅
+        logger.info("\n[Environment Variables]")
+        logger.info(f"ADMIN_USERNAME from os.environ: {os.environ.get('ADMIN_USERNAME')}")
+        logger.info(f"ADMIN_PASSWORD from os.environ: {os.environ.get('ADMIN_PASSWORD') is not None}")
+        logger.info(f"ADMIN_USERNAME from os.getenv: {os.getenv('ADMIN_USERNAME')}")
+        logger.info(f"ADMIN_PASSWORD from os.getenv: {os.getenv('ADMIN_PASSWORD') is not None}")
         
         logger.info(f"환경변수에서 가져온 사용자명: {valid_username if valid_username else '정의되지 않음'}")
         logger.info(f"환경변수에서 비밀번호 가져온 여부: {len(valid_password) > 0 if valid_password else False}")
         
+        # 허깅페이스에서 환경변수가 로드되지 않을 경우 기본값 사용
+        if not valid_username or not valid_password:
+            logger.warning("환경변수에서 사용자 자격증명을 찾을 수 없어 기본값 사용")
+            valid_username = "admin"
+            valid_password = "rag12345"
+        
         if username == valid_username and password == valid_password:
             logger.info(f"로그인 성공: {username}")
             # 세션 상태 확인 및 로깅
@@ -234,7 +486,11 @@ def login():
             # 세션 설정 후 로깅
             logger.info(f"세션 설정 후 세션 상태: {session}")
             logger.info("세션 설정 완료, 리디렉션 시도")
-            return redirect(url_for('index'))
+            
+            # 세션 쿠키 설정 확인
+            response = redirect(url_for('index'))
+            logger.info(f"Response Headers: {response.headers}")
+            return response
         else:
             logger.warning("로그인 실패: 아이디 또는 비밀번호 불일치")
             # 어떤 부분이 일치하지 않는지 상세 로깅
@@ -443,6 +699,113 @@ def voice_chat():
     audio_file = request.files['audio']
     logger.info(f"수신된 파일: {audio_file.filename}")
     
+    try:
+        # 오디오 파일 읽기
+        with audio_file.stream as f:
+            audio_bytes = f.read()
+        
+        # 음성인식 (VitoSTT)
+        stt = VitoSTT()
+        stt_result = stt.transcribe_audio(audio_bytes, language="ko")
+        
+        if not stt_result["success"]:
+            logger.error(f"음성인식 실패: {stt_result['error']}")
+            return jsonify({
+                "error": stt_result["error"],
+                "details": stt_result.get("details", "")
+            }), 500
+        
+        transcription = stt_result["text"]
+        if not transcription:
+            logger.warning("음성인식 결과가 비어있습니다.")
+            return jsonify({"error": "음성에서 텍스트를 인식하지 못했습니다."}), 400
+        
+        logger.info(f"음성인식 성공: {transcription[:50]}...")
+        
+        # 검색기 호출: 인식된 텍스트를 쿼리로 사용
+        sources = retriever.search(transcription, top_k=5, first_stage_k=6)
+        if not sources:
+            logger.warning("검색된 소스가 없습니다.")
+            sources = []
+        
+        # 소스 문서 내용을 컨텍스트로 준비
+        context = DocumentProcessor.prepare_rag_context(sources, field="text")
+        logger.info(f"검색된 소스 수: {len(sources)}")
+        
+        # LLM 호출: 질문과 컨텍스트를 바탕으로 응답 생성
+        llm_id = request.form.get('llm_id', None)  # 클라이언트에서 LLM 선택이 제공되면 사용
+        answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
+        
+        # 소스 정보 추출
+        enhanced_sources = []
+        for doc in sources:
+            if "source" in doc:
+                source_info = {
+                    "source": doc.get("source", "Unknown"),
+                    "score": doc.get("rerank_score", doc.get("score", 0))
+                }
+                
+                # CSV 파일인 경우 첫 번째 컨텐츠 데이터를 추출하여 표시
+                if "text" in doc and "filetype" in doc and doc["filetype"] == "csv":
+                    # 디버깅 로그 추가
+                    logger.info(f"[음성챗] CSV 파일 처리: {doc['source']}")
+                    logger.info(f"[음성챗] CSV 내용 처음 부분: {doc['text'][:100]}...")
+
+                    # 첫 번째 라인이나 내용에서 콤럼 값 추출 시도
+                    try:
+                        # 텍스트의 처음 부분을 추출
+                        text_lines = doc["text"].strip().split('\n')
+                        logger.info(f"[음성챗] CSV 라인 개수: {len(text_lines)}")
+                        
+                        if len(text_lines) > 0:
+                            first_line = text_lines[0].strip()
+                            logger.info(f"[음성챗] CSV 첫 줄: {first_line}")
+                            
+                            if ',' in first_line:  # CSV 형식이면
+                                first_columns = first_line.split(',')
+                                logger.info(f"[음성챗] CSV 콤럼 개수: {len(first_columns)}")
+                                
+                                first_column = first_columns[0].strip()
+                                logger.info(f"[음성챗] CSV 첫 번째 콤럼 값: '{first_column}'")
+                                source_info["id"] = first_column
+                                logger.info(f"[음성챗] source_info에 id 추가: {source_info}")
+                            else:
+                                logger.warning(f"[음성챗] CSV 파일이지만 코마가 없음: {first_line}")
+                        else:
+                            logger.warning(f"[음성챗] CSV 파일이지만 라인이 없음: {doc['source']}")
+                    except Exception as e:
+                        logger.warning(f"[음성챗] CSV 첫 번째 콤럼 추출 실패: {e}")
+                
+                enhanced_sources.append(source_info)
+        
+        # 최종 응답 구조 로깅
+        response_data = {
+            "transcription": transcription,
+            "answer": answer,
+            "sources": enhanced_sources,
+            "llm": llm_interface.get_current_llm_details()
+        }
+        logger.debug(f"[음성챗] 최종 API 응답 구조: {json.dumps(response_data, ensure_ascii=False, indent=2)[:500]}...")
+        
+        return jsonify(response_data)
+    
+    except Exception as e:
+        logger.error(f"음성 챗 처리 중 오류 발생: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "음성 처리 중 내부 오류 발생",
+            "details": str(e)
+        }), 500
+    """
+    logger.info("음성 챗 요청 수신")
+    
+    # 오디오 파일 확인
+    if 'audio' not in request.files:
+        logger.error("오디오 파일이 제공되지 않음")
+        return jsonify({"error": "오디오 파일이 제공되지 않았습니다."}), 400
+    
+    audio_file = request.files['audio']
+    logger.info(f"수신된 파일: {audio_file.filename}")
+    
     try:
         # 오디오 파일 읽기
         with audio_file.stream as f: