fix

app/app.py

@@ -46,12 +46,20 @@ if not ADMIN_PASSWORD:
 # --- 로컬 모듈 임포트 ---
 # MockComponent 정의 (임포트 실패 시 대체)
 class MockComponent:
+    def __init__(self):
+        self.is_mock = True
+    
+    def search(self, query, top_k=5, first_stage_k=None):
+        """빈 검색 결과를 반환합니다."""
+        logger.warning(f"MockComponent.search 호출됨 (쿼리: {query[:30]}...)")
+        return []
+    
     def __getattr__(self, name):
         # Mock 객체의 어떤 속성이나 메소드 호출 시 경고 로그 출력 및 기본값 반환
         logger.warning(f"MockComponent에서 '{name}' 접근 시도됨 (실제 모듈 로드 실패)")
         # 메소드 호출 시에는 아무것도 안 하는 함수 반환
-        if name in ['search', 'add_documents', 'save', 'transcribe_audio', 'rag_generate', 'set_llm', 'get_current_llm_details', 'prepare_rag_context', 'csv_to_documents', 'text_to_documents', 'load_documents_from_directory']:
-            return lambda *args, **kwargs: logger.warning(f"Mocked method '{name}' called") or (None if name != 'search' else []) # search는 빈 리스트 반환
+        if name in ['add_documents', 'save', 'transcribe_audio', 'rag_generate', 'set_llm', 'get_current_llm_details', 'prepare_rag_context', 'csv_to_documents', 'text_to_documents', 'load_documents_from_directory']:
+            return lambda *args, **kwargs: logger.warning(f"Mocked method '{name}' called") or None
         # 속성 접근 시에는 None 반환
         return None
 
@@ -188,7 +196,8 @@ def init_retriever():
         logger.error(f"기본 검색기 초기화/로드 실패: {e}", exc_info=True)
         base_retriever = MockComponent() # 실패 시 Mock 사용
         retriever = MockComponent()
-        return None # 초기화 실패
+        logger.info("Mock 검색기를 대체로 사용합니다.")
+        return retriever # 초기화 실패해도 Mock 검색기 반환 (None 대신)
 
     # 2. 데이터 폴더 문서 로드 (기본 검색기가 비어있을 때)
     needs_loading = not hasattr(base_retriever, 'documents') or not getattr(base_retriever, 'documents', [])

app/app_routes.py

@@ -191,205 +191,300 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
     @login_required
     def chat():
         """텍스트 기반 채봇 API"""
-        is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
-        if not is_ready:
-             return jsonify({"error": "앱 초기화 중...", "answer": "죄송합니다. 시스템이 아직 준비 중입니다.", "sources": []}), 503
-
-        # retriever 객체 및 필수 메소드 확인
-        if retriever is None or not hasattr(retriever, 'search'):
-            logger.warning("채팅 API 요청 시 retriever가 준비되지 않았거나 search 메소드가 없습니다.")
-            return jsonify({
-                "answer": "죄송합니다. 검색 엔진이 아직 준비되지 않았습니다. 잠시 후 다시 시도해주세요.",
-                "sources": [],
-                "error": "Retriever not ready"
-            }), 503 # 서비스 불가 상태
-
         try:
+            # 앱이 준비되었는지 확인
+            is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
+            if not is_ready:
+                logger.warning("앱이 아직 초기화 중입니다.")
+                return jsonify({
+                    "error": "앱 초기화 중...", 
+                    "answer": "죄송합니다. 시스템이 아직 준비 중입니다.", 
+                    "sources": []
+                }), 503
+
             data = request.get_json()
             if not data or 'query' not in data:
                 return jsonify({"error": "쿼리가 제공되지 않았습니다."}), 400
 
             query = data['query']
             logger.info(f"텍스트 쿼리 수신: {query[:100]}...")
-
-            # RAG 검색 수행
-            search_results = retriever.search(query, top_k=5, first_stage_k=6)
-
-            # DocumentProcessor 객체 및 메소드 확인
-            if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
-                 logger.error("DocumentProcessor가 준비되지 않았거나 prepare_rag_context 메소드가 없습니다.")
-                 return jsonify({"error": "문서 처리기 오류"}), 500
-            context = DocumentProcessor.prepare_rag_context(search_results, field="text")
-
-            if not context:
-                logger.warning(f"쿼리 '{query[:50]}...'에 대한 검색 결과 없음.")
-
-            # LLM 인터페이스 객체 및 메소드 확인
-            llm_id = data.get('llm_id', None)
-            if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
-                 logger.error("LLM 인터페이스가 준비되지 않았거나 rag_generate 메소드가 없습니다.")
-                 return jsonify({"error": "LLM 인터페이스 오류"}), 500
-
-            # LLM 호출
-            if not context:
-                answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
-                logger.info("컨텍스트 없이 기본 응답 생성")
-            else:
-                answer = llm_interface.rag_generate(query, context, llm_id=llm_id)
-                logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
-
-            # 소스 정보 추출
-            sources = []
-            if search_results:
-                for result in search_results:
-                    if not isinstance(result, dict):
-                        logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
-                        continue
-                    source_info = {}
-                    source_key = result.get("source")
-                    if not source_key and "metadata" in result and isinstance(result["metadata"], dict):
-                        source_key = result["metadata"].get("source")
-                    if source_key:
-                        source_info["source"] = source_key
-                        source_info["score"] = result.get("rerank_score", result.get("score", 0))
-                        filetype = result.get("filetype")
-                        if not filetype and "metadata" in result and isinstance(result["metadata"], dict):
-                            filetype = result["metadata"].get("filetype")
-                        if "text" in result and filetype == "csv":
-                            try:
-                                text_lines = result["text"].strip().split('\n')
-                                if text_lines:
-                                    first_line = text_lines[0].strip()
-                                    if ',' in first_line:
-                                        first_column = first_line.split(',')[0].strip()
-                                        source_info["id"] = first_column
-                            except Exception as e:
-                                logger.warning(f"CSV 소스 ID 추출 실패 ({source_info.get('source')}): {e}")
+            
+            # 검색 엔진 처리 부분 수정
+            search_results = []
+            search_warning = None
+            try:
+                # retriever 상태 검증
+                if retriever is None:
+                    logger.warning("Retriever가 초기화되지 않았습니다.")
+                    search_warning = "검색 기능이 아직 준비되지 않았습니다."
+                elif hasattr(retriever, 'is_mock') and retriever.is_mock:
+                    logger.info("Mock Retriever 사용 중 - 검색 결과 없음.")
+                    search_warning = "검색 인덱스가 아직 구축 중입니다. 기본 응답만 제공됩니다."
+                elif not hasattr(retriever, 'search'):
+                    logger.warning("Retriever에 search 메소드가 없습니다.")
+                    search_warning = "검색 기능이 현재 제한되어 있습니다."
+                else:
+                    logger.info(f"검색 수행: {query[:50]}...")
+                    search_results = retriever.search(query, top_k=5, first_stage_k=6)
+                    if not search_results:
+                        logger.info("검색 결과가 없습니다.")
+                    else:
+                        logger.info(f"검색 결과: {len(search_results)}개 항목")
+            except Exception as e:
+                logger.error(f"검색 중 오류 발생: {str(e)}", exc_info=True)
+                search_results = []
+                search_warning = f"검색 중 오류 발생: {str(e)}"
+            
+            # LLM 응답 생성
+            try:
+                # DocumentProcessor 객체 및 메소드 확인
+                context = ""
+                if search_results:
+                    if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
+                        logger.warning("DocumentProcessor가 준비되지 않았거나 prepare_rag_context 메소드가 없습니다.")
+                    else:
+                        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
+                        logger.info(f"컨텍스트 준비 완료 (길이: {len(context) if context else 0}자)")
+
+                # LLM 인터페이스 객체 및 메소드 확인
+                llm_id = data.get('llm_id', None)
+                
+                if not context:
+                    if search_warning:
+                        logger.info(f"컨텍스트 없음, 검색 경고: {search_warning}")
+                        answer = f"죄송합니다. 질문에 대한 답변을 찾을 수 없습니다. ({search_warning})"
+                    else:
+                        logger.info("컨텍스트 없이 기본 응답 생성")
+                        answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
+                else:
+                    if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
+                        logger.error("LLM 인터페이스가 준비되지 않았거나 rag_generate 메소드가 없습니다.")
+                        answer = "죄송합니다. 현재 LLM 서비스를 사용할 수 없습니다."
+                    else:
+                        # LLM 호출 전에 경고 메시지 추가
+                        if search_warning:
+                            modified_query = f"{query}\n\n참고: {search_warning}"
+                            logger.info(f"경고 메시지와 함께 쿼리 생성: {modified_query[:100]}...")
+                        else:
+                            modified_query = query
+                        
+                        answer = llm_interface.rag_generate(modified_query, context, llm_id=llm_id)
+                        logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+
+                # 소스 정보 추출
+                sources = []
+                if search_results:
+                    for result in search_results:
+                        if not isinstance(result, dict):
+                            logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
+                            continue
+                        source_info = {}
+                        source_key = result.get("source")
+                        if not source_key and "metadata" in result and isinstance(result["metadata"], dict):
+                            source_key = result["metadata"].get("source")
+                        
+                        if source_key:
+                            source_info["name"] = os.path.basename(source_key)
+                            source_info["path"] = source_key
+                        else:
+                            source_info["name"] = "알 수 없는 소스"
+                        
+                        if "score" in result:
+                            source_info["score"] = result["score"]
+                        if "rerank_score" in result:
+                            source_info["rerank_score"] = result["rerank_score"]
+                            
                         sources.append(source_info)
 
-            # 최종 응답
-            response_data = {
-                "answer": answer,
-                "sources": sources,
-                "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
-            }
-            return jsonify(response_data)
-
+                return jsonify({
+                    "answer": answer,
+                    "sources": sources,
+                    "search_warning": search_warning
+                })
+                
+            except Exception as e:
+                logger.error(f"LLM 응답 생성 중 오류 발생: {str(e)}", exc_info=True)
+                return jsonify({
+                    "answer": f"죄송합니다. 응답 생성 중 오류가 발생했습니다: {str(e)}",
+                    "sources": [],
+                    "error": str(e)
+                })
+                
         except Exception as e:
-            logger.error(f"채팅 처리 중 오류 발생: {e}", exc_info=True)
-            return jsonify({"error": f"처리 중 오류가 발생했습니다: {str(e)}"}), 500
+            logger.error(f"채팅 API에서 예상치 못한 오류 발생: {str(e)}", exc_info=True)
+            return jsonify({
+                "error": f"예상치 못한 오류 발생: {str(e)}",
+                "answer": "죄송합니다. 서버에서 오류가 발생했습니다.",
+                "sources": []
+            }), 500
 
     # --- Voice Chat API ---
     @app.route('/api/voice', methods=['POST'])
     @login_required
     def voice_chat():
         """음성 챗 API 엔드포인트"""
-        is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
-        if not is_ready:
-             return jsonify({"error": "앱 초기화 중..."}), 503
-
-        # 필수 컴포넌트 확인
-        if retriever is None or not hasattr(retriever, 'search'):
-            logger.error("음성 API 요청 시 retriever가 준비되지 않음")
-            return jsonify({"error": "검색 엔진 준비 안됨"}), 503
-        if stt_client is None or not hasattr(stt_client, 'transcribe_audio'):
-            logger.error("음성 API 요청 시 STT 클라이언트가 준비되지 않음")
-            return jsonify({"error": "음성 인식 서비스 준비 안됨"}), 503
-        if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
-             logger.error("음성 API 요청 시 LLM 인터페이스가 준비되지 않음")
-             return jsonify({"error": "LLM 인터페이스 오류"}), 500
-        if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
-             logger.error("음성 API 요청 시 DocumentProcessor가 준비되지 않음")
-             return jsonify({"error": "문서 처리기 오류"}), 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} ({audio_file.content_type})")
-
         try:
-            # 오디오 파일 임시 저장 및 처리
-            with tempfile.NamedTemporaryFile(delete=True, suffix=os.path.splitext(audio_file.filename)[1]) as temp_audio:
-                audio_file.save(temp_audio.name)
-                logger.info(f"오디오 파일을 임시 저장: {temp_audio.name}")
-                # STT 수행 (바이트 전달 가정)
-                with open(temp_audio.name, 'rb') as f_bytes:
-                    audio_bytes = f_bytes.read()
-                stt_result = stt_client.transcribe_audio(audio_bytes, language="ko")
-
-            # STT 결과 처리
-            if not isinstance(stt_result, dict) or not stt_result.get("success"):
-                error_msg = stt_result.get("error", "알 수 없는 STT 오류") if isinstance(stt_result, dict) else "STT 결과 형식 오류"
-                logger.error(f"음성인식 실패: {error_msg}")
-                return jsonify({"error": "음성인식 실패", "details": error_msg}), 500
-
-            transcription = stt_result.get("text", "")
-            if not transcription:
-                logger.warning("음성인식 결과가 비어있습니다.")
+            # 앱이 준비되었는지 확인
+            is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
+            if not is_ready:
+                logger.warning("앱이 아직 초기화 중입니다.")
+                return jsonify({"error": "앱 초기화 중...", "answer": "죄송합니다. 시스템이 아직 준비 중입니다."}), 503
+            
+            # STT 클라이언트 확인
+            if stt_client is None or not hasattr(stt_client, 'transcribe_audio'):
+                logger.error("음성 API 요청 시 STT 클라이언트가 준비되지 않음")
+                return jsonify({"error": "음성 인식 서비스 준비 안됨"}), 503
+            
+            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} ({audio_file.content_type})")
+            
+            try:
+                # 오디오 파일 임시 저장 및 처리
+                with tempfile.NamedTemporaryFile(delete=True, suffix=os.path.splitext(audio_file.filename)[1]) as temp_audio:
+                    audio_file.save(temp_audio.name)
+                    logger.info(f"오디오 파일을 임시 저장: {temp_audio.name}")
+                    # STT 수행 (바이트 전달 가정)
+                    with open(temp_audio.name, 'rb') as f_bytes:
+                        audio_bytes = f_bytes.read()
+                    stt_result = stt_client.transcribe_audio(audio_bytes, language="ko")
+                
+                # STT 결과 처리
+                if not isinstance(stt_result, dict) or not stt_result.get("success"):
+                    error_msg = stt_result.get("error", "알 수 없는 STT 오류") if isinstance(stt_result, dict) else "STT 결과 형식 오류"
+                    logger.error(f"음성인식 실패: {error_msg}")
+                    return jsonify({"error": "음성인식 실패", "details": error_msg}), 500
+                
+                transcription = stt_result.get("text", "")
+                if not transcription:
+                    logger.warning("음성인식 결과가 비어있습니다.")
+                    return jsonify({
+                        "transcription": "",
+                        "answer": "음성에서 텍스트를 인식하지 못했습니다.",
+                        "sources": []
+                    }), 200 # 200 OK와 메시지
+                
+                logger.info(f"음성인식 성공: {transcription[:50]}...")
+                
+                # --- RAG 및 LLM 호출 (Chat API와 동일 로직) ---
+                # 검색 엔진 처리 부분
+                search_results = []
+                search_warning = None
+                try:
+                    # retriever 상태 검증
+                    if retriever is None:
+                        logger.warning("Retriever가 초기화되지 않았습니다.")
+                        search_warning = "검색 기능이 아직 준비되지 않았습니다."
+                    elif hasattr(retriever, 'is_mock') and retriever.is_mock:
+                        logger.info("Mock Retriever 사용 중 - 검색 결과 없음.")
+                        search_warning = "검색 인덱스가 아직 구축 중입니다. 기본 응답만 제공됩니다."
+                    elif not hasattr(retriever, 'search'):
+                        logger.warning("Retriever에 search 메소드가 없습니다.")
+                        search_warning = "검색 기능이 현재 제한되어 있습니다."
+                    else:
+                        logger.info(f"검색 수행: {transcription[:50]}...")
+                        search_results = retriever.search(transcription, top_k=5, first_stage_k=6)
+                        if not search_results:
+                            logger.info("검색 결과가 없습니다.")
+                        else:
+                            logger.info(f"검색 결과: {len(search_results)}개 항목")
+                except Exception as e:
+                    logger.error(f"검색 중 오류 발생: {str(e)}", exc_info=True)
+                    search_results = []
+                    search_warning = f"검색 중 오류 발생: {str(e)}"
+                
+                # LLM 응답 생성
+                context = ""
+                if search_results:
+                    if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
+                        logger.warning("DocumentProcessor가 준비되지 않았거나 prepare_rag_context 메소드가 없습니다.")
+                    else:
+                        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
+                        logger.info(f"컨텍스트 준비 완료 (길이: {len(context) if context else 0}자)")
+                
+                # LLM 인터페이스 호출
+                llm_id = request.form.get('llm_id', None) # form 데이터에서 llm_id 가져오기
+                
+                if not context:
+                    if search_warning:
+                        logger.info(f"컨텍스트 없음, 검색 경고: {search_warning}")
+                        answer = f"죄송합니다. 질문에 대한 답변을 찾을 수 없습니다. ({search_warning})"
+                    else:
+                        logger.info("컨텍스트 없��� 기본 응답 생성")
+                        answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
+                else:
+                    if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
+                        logger.error("LLM 인터페이스가 준비되지 않았거나 rag_generate 메소드가 없습니다.")
+                        answer = "죄송합니다. 현재 LLM 서비스를 사용할 수 없습니다."
+                    else:
+                        # LLM 호출 전에 경고 메시지 추가
+                        if search_warning:
+                            modified_query = f"{transcription}\n\n참고: {search_warning}"
+                            logger.info(f"경고 메시지와 함께 쿼리 생성: {modified_query[:100]}...")
+                        else:
+                            modified_query = transcription
+                        
+                        answer = llm_interface.rag_generate(modified_query, context, llm_id=llm_id)
+                        logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+                
+                # 소스 정보 추출
+                sources = []
+                if search_results:
+                    for result in search_results:
+                        if not isinstance(result, dict):
+                            logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
+                            continue
+                        source_info = {}
+                        source_key = result.get("source")
+                        if not source_key and "metadata" in result and isinstance(result["metadata"], dict):
+                            source_key = result["metadata"].get("source")
+                        
+                        if source_key:
+                            source_info["name"] = os.path.basename(source_key)
+                            source_info["path"] = source_key
+                        else:
+                            source_info["name"] = "알 수 없는 소스"
+                        
+                        if "score" in result:
+                            source_info["score"] = result["score"]
+                        if "rerank_score" in result:
+                            source_info["rerank_score"] = result["rerank_score"]
+                        
+                        sources.append(source_info)
+                
+                # 최종 응답
+                response_data = {
+                    "transcription": transcription,
+                    "answer": answer,
+                    "sources": sources,
+                    "search_warning": search_warning
+                }
+                
+                # LLM 정보 추가 (옵션)
+                if hasattr(llm_interface, 'get_current_llm_details'):
+                    response_data["llm"] = llm_interface.get_current_llm_details()
+                
+                return jsonify(response_data)
+            
+            except Exception as e:
+                logger.error(f"음성 챗 처리 중 오류 발생: {e}", exc_info=True)
                 return jsonify({
-                    "transcription": "",
-                    "answer": "음성에서 텍스트를 인식하지 못했습니다.",
-                    "sources": [],
-                    "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
-                }), 200 # 200 OK와 메시지
-
-            logger.info(f"음성인식 성공: {transcription[:50]}...")
-
-            # --- RAG 및 LLM 호출 (Chat API와 동일 로직) ---
-            search_results = retriever.search(transcription, top_k=5, first_stage_k=6)
-            context = DocumentProcessor.prepare_rag_context(search_results, field="text")
-
-            llm_id = request.form.get('llm_id', None) # form 데이터에서 llm_id 가져오기
-            if not context:
-                answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
-                logger.info("컨텍스트 없이 기본 응답 생성")
-            else:
-                answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
-                logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
-
-            # 소스 정보 추출 (Chat API와 동일 로직)
-            sources = []
-            if search_results:
-                 for result in search_results:
-                     if not isinstance(result, dict): continue
-                     source_info = {}
-                     source_key = result.get("source")
-                     if not source_key and "metadata" in result and isinstance(result["metadata"], dict):
-                         source_key = result["metadata"].get("source")
-                     if source_key:
-                         source_info["source"] = source_key
-                         source_info["score"] = result.get("rerank_score", result.get("score", 0))
-                         filetype = result.get("filetype")
-                         if not filetype and "metadata" in result and isinstance(result["metadata"], dict):
-                             filetype = result["metadata"].get("filetype")
-                         if "text" in result and filetype == "csv":
-                             try:
-                                 text_lines = result["text"].strip().split('\n')
-                                 if text_lines:
-                                     first_line = text_lines[0].strip()
-                                     if ',' in first_line:
-                                         first_column = first_line.split(',')[0].strip()
-                                         source_info["id"] = first_column
-                             except Exception as e:
-                                 logger.warning(f"[음성챗] CSV 소스 ID 추출 실패 ({source_info.get('source')}): {e}")
-                         sources.append(source_info)
-
-            # 최종 응답
-            response_data = {
-                "transcription": transcription,
-                "answer": answer,
-                "sources": sources,
-                "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
-            }
-            return jsonify(response_data)
-
+                    "error": "음성 처리 중 내부 오류 발생", 
+                    "details": str(e),
+                    "answer": "죄송합니다. 오디오 처리 중 오류가 발생했습니다."
+                }), 500
+                
         except Exception as e:
-            logger.error(f"음성 챗 처리 중 오류 발생: {e}", exc_info=True)
-            return jsonify({"error": "음성 처리 중 내부 오류 발생", "details": str(e)}), 500
+            logger.error(f"음성 API에서 예상치 못한 오류 발생: {str(e)}", exc_info=True)
+            return jsonify({
+                "error": f"예상치 못한 오류 발생: {str(e)}",
+                "answer": "죄송합니다. 서버에서 오류가 발생했습니다."
+            }), 500
 
     # --- Document Upload API ---
     @app.route('/api/upload', methods=['POST'])