Add application file

app/app.py

@@ -1,201 +1,4 @@
-@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 검색 챗봇 웹 애플리케이션
 """
 
@@ -751,7 +554,7 @@ def voice_chat():
                     logger.info(f"[음성챗] CSV 파일 처리: {doc['source']}")
                     logger.info(f"[음성챗] CSV 내용 처음 부분: {doc['text'][:100]}...")
 
-                    # 첫 번째 라인이나 내용에서 콤럼 값 추출 시도
+                    # 첫 번째 라인이나 내용에서 컬럼 값 추출 시도
                     try:
                         # 텍스트의 처음 부분을 추출
                         text_lines = doc["text"].strip().split('\n')
@@ -763,10 +566,10 @@ def voice_chat():
                             
                             if ',' in first_line:  # CSV 형식이면
                                 first_columns = first_line.split(',')
-                                logger.info(f"[음성챗] CSV 콤럼 개수: {len(first_columns)}")
+                                logger.info(f"[음성챗] CSV 컬럼 개수: {len(first_columns)}")
                                 
                                 first_column = first_columns[0].strip()
-                                logger.info(f"[음성챗] CSV 첫 번째 콤럼 값: '{first_column}'")
+                                logger.info(f"[음성챗] CSV 첫 번째 컬럼 값: '{first_column}'")
                                 source_info["id"] = first_column
                                 logger.info(f"[음성챗] source_info에 id 추가: {source_info}")
                             else:
@@ -774,7 +577,7 @@ def voice_chat():
                         else:
                             logger.warning(f"[음성챗] CSV 파일이지만 라인이 없음: {doc['source']}")
                     except Exception as e:
-                        logger.warning(f"[음성챗] CSV 첫 번째 콤럼 추출 실패: {e}")
+                        logger.warning(f"[음성챗] CSV 첫 번째 컬럼 추출 실패: {e}")
                 
                 enhanced_sources.append(source_info)
         
@@ -795,110 +598,206 @@ def voice_chat():
             "error": "음성 처리 중 내부 오류 발생",
             "details": str(e)
         }), 500
-    """
-    logger.info("음성 챗 요청 수신")
-    
-    # 오디오 파일 확인
-    if 'audio' not in request.files:
-        logger.error("오디오 파일이 제공되지 않음")
-        return jsonify({"error": "오디오 파일이 제공되지 않았습니다."}), 400
+
+@app.route('/api/upload', methods=['POST'])
+@login_required
+def upload_document():
+    """지식베이스 문서 업로드 API"""
+    global base_retriever, retriever, app_ready
     
-    audio_file = request.files['audio']
-    logger.info(f"수신된 파일: {audio_file.filename}")
+    # 앱 준비 상태 확인
+    if not app_ready:
+        return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
     
     try:
-        # 오디오 파일 읽기
-        with audio_file.stream as f:
-            audio_bytes = f.read()
-        
-        # 음성인식 (VitoSTT)
-        stt = VitoSTT()
-        stt_result = stt.transcribe_audio(audio_bytes, language="ko")
+        # 파일이 요청에 포함되어 있는지 확인
+        if 'document' not in request.files:
+            return jsonify({"error": "문서 파일이 제공되지 않았습니다."}), 400
         
-        if not stt_result["success"]:
-            logger.error(f"음성인식 실패: {stt_result['error']}")
-            return jsonify({
-                "error": stt_result["error"],
-                "details": stt_result.get("details", "")
-            }), 500
+        doc_file = request.files['document']
+        logger.info(f"받은 파일명: {doc_file.filename}")
         
-        transcription = stt_result["text"]
-        if not transcription:
-            logger.warning("음성인식 결과가 비어있습니다.")
-            return jsonify({"error": "음성에서 텍스트를 인식하지 못했습니다."}), 400
+        # 파일명이 비어있는지 확인
+        if doc_file.filename == '':
+            return jsonify({"error": "선택된 파일이 없습니다."}), 400
         
-        logger.info(f"음성인식 성공: {transcription[:50]}...")
+        # 파일 형식 확인
+        if not allowed_doc_file(doc_file.filename):
+            logger.error(f"허용되지 않는 파일 형식: {doc_file.filename}")
+            return jsonify({"error": "허용되지 않는 파일 형식입니다. 현재 허용된 파일 형식: {}".format(', '.join(ALLOWED_DOC_EXTENSIONS))}), 400
         
-        # 검색기 호출: 인식된 텍스트를 쿼리로 사용
-        sources = retriever.search(transcription, top_k=5, first_stage_k=6)
-        if not sources:
-            logger.warning("검색된 소스가 없습니다.")
-            sources = []
+        # 파일명 보안 처리
+        filename = secure_filename(doc_file.filename)
         
-        # 소스 문서 내용을 컨텍스트로 준비
-        context = DocumentProcessor.prepare_rag_context(sources, field="text")
-        logger.info(f"검색된 소스 수: {len(sources)}")
+        # 데이터 폴더에 저장
+        filepath = os.path.join(app.config['DATA_FOLDER'], filename)
+        doc_file.save(filepath)
         
-        # LLM 호출: 질문과 컨텍스트를 바탕으로 응답 생성
-        llm_id = request.form.get('llm_id', None)  # 클라이언트에서 LLM 선택이 제공되면 사용
-        answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
+        logger.info(f"문서가 저장되었습니다: {filepath}")
         
-        # 소스 정보 추출
-        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))
-                }
+        # 문서 처리
+        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)
                 
-                # 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}")
+                # 인덱스 저장
+                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
                 
-                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({
+                    "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
         
-        return jsonify(response_data)
-    
     except Exception as e:
-        logger.error(f"음성 챗 처리 중 오류 발생: {str(e)}", exc_info=True)
+        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({
-            "error": "음성 처리 중 내부 오류 발생",
-            "details": str(e)
-        }), 500
+            "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"현재 세션 내용: {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