Fix requirements.txt file

app/app.py

@@ -236,99 +236,83 @@ def chat():
 
 @app.route('/api/voice', methods=['POST'])
 def voice_chat():
-    """음성 기반 챗봇 API"""
-    global retriever, app_ready
+    """
+    음성 챗 API 엔드포인트: 오디오 파일을 받아 텍스트로 변환하고, 질문에 대한 응답과 소스를 반환
+
+    Returns:
+        JSON 응답:
+        - transcription: 인식된 텍스트
+        - answer: LLM에서 생성한 응답
+        - sources: 검색된 문서 소스 (리스트)
+        - error: 오류 발생 시 오류 메시지
+        - details: 오류 상세 정보 (선택적)
+    """
+    logger.info("음성 챗 요청 수신")
     
-    # 앱 준비 상태 확인
-    if not app_ready:
-        return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+    # 오디오 파일 확인
+    if 'audio' not in request.files:
+        logger.error("오디오 파일이 제공되지 않음")
+        return jsonify({"error": "오디오 파일이 제공되지 않았습니다."}), 400
+    
+    audio_file = request.files['audio']
+    logger.info(f"수신된 파일: {audio_file.filename}")
     
     try:
-        # 파일이 요청에 포함되어 있는지 확인
-        if 'audio' not in request.files:
-            return jsonify({"error": "오디오 파일이 제공되지 않았습니다."}), 400
+        # 오디오 파일 읽기
+        with audio_file.stream as f:
+            audio_bytes = f.read()
         
-        audio_file = request.files['audio']
+        # 음성인식 (VitoSTT)
+        stt = VitoSTT()
+        stt_result = stt.transcribe_audio(audio_bytes, language="ko")
         
-        # 파일명이 비어있는지 확인
-        if audio_file.filename == '':
-            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
         
-        # 파일 형식 확인
-        if not allowed_audio_file(audio_file.filename):
-            return jsonify({"error": "허용되지 않는 파일 형식입니다."}), 400
+        transcription = stt_result["text"]
+        if not transcription:
+            logger.warning("음성인식 결과가 비어있습니다.")
+            return jsonify({"error": "음성에서 텍스트를 인식하지 못했습니다."}), 400
         
-        # 임시 파일로 저장하여 처리
-        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
-            audio_file.save(temp_file.name)
-            temp_path = temp_file.name
+        logger.info(f"음성인식 성공: {transcription[:50]}...")
         
-        try:
-            # 파일 읽기
-            with open(temp_path, "rb") as f:
-                audio_bytes = f.read()
-            
-            # STT로 음성을 텍스트로 변환
-            logger.info("VITO STT로 음성을 텍스트로 변환 중...")
-            stt_result = stt_client.transcribe_audio(audio_bytes)
-            
-            if not stt_result["success"]:
-                logger.error(f"STT 처리 실패: {stt_result.get('error', 'Unknown error')}")
-                return jsonify({
-                    "error": f"음성 인식 실패: {stt_result.get('error', 'Unknown error')}"
-                }), 500
-            
-            query = stt_result["text"]
-            logger.info(f"인식된 쿼리: {query}")
-            
-            if not query:
-                return jsonify({
-                    "error": "음성을 텍스트로 변환할 수 없습니다. 다시 시도하세요."
-                }), 400
-            
-            # RAG 검색 수행 (재순위화 적용)
-            search_results = retriever.search(query, top_k=5, first_stage_k=20)
-            
-            # 검색 결과에서 컨텍스트 추출
-            context = DocumentProcessor.prepare_rag_context(search_results, field="text")
-            
-            if not context:
-                logger.warning("검색 결과가 없습니다.")
-                return jsonify({
-                    "transcription": query,
-                    "answer": "죄송합니다. 관련 정보를 찾을 수 없습니다.",
-                    "sources": []
-                })
-            
-            # LLM에 질의
-            answer = llm_client.rag_generate(query, context)
-            
-            # 소스 정보 추출
+        # 검색기 호출: 인식된 텍스트를 쿼리로 사용
+        sources = retriever.search(transcription)
+        if not sources:
+            logger.warning("검색된 소스가 없습니다.")
             sources = []
-            for result in search_results:
-                if "source" in result:
-                    source_info = {
-                        "source": result.get("source", "Unknown"),
-                        "score": result.get("rerank_score", result.get("score", 0))
-                    }
-                    sources.append(source_info)
-            
-            return jsonify({
-                "transcription": query,
-                "answer": answer,
-                "sources": sources
-            })
-            
-        finally:
-            # 임시 파일 정리
-            try:
-                os.unlink(temp_path)
-            except Exception as e:
-                logger.error(f"임시 파일 삭제 중 오류 발생: {e}")
         
+        # 소스 문서 내용을 컨텍스트로 준비
+        context = "\n".join([doc["content"] for doc in sources])
+        logger.info(f"검색된 소스 수: {len(sources)}")
+        
+        # LLM 호출: 질문과 컨텍스트를 바탕으로 응답 생성
+        prompt = f"질문: {transcription}\n\n컨텍스트:\n{context}\n\n답변:"
+        answer = llm.generate(prompt)
+        
+        if not answer:
+            logger.error("LLM 응답 생성 실패")
+            return jsonify({"error": "응답 생성에 실패했습니다."}), 500
+        
+        logger.info(f"LLM 응답 생성 성공: {answer[:50]}...")
+        
+        # 응답 반환
+        return jsonify({
+            "transcription": transcription,
+            "answer": answer,
+            "sources": sources  # [{ "content": "...", "metadata": {...} }, ...]
+        })
+    
     except Exception as e:
-        logger.error(f"음성 처리 중 오류 발생: {e}", exc_info=True)
-        return jsonify({"error": f"처리 중 오류가 발생했습니다: {str(e)}"}), 500
+        logger.error(f"음성 챗 처리 중 오류 발생: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "음성 처리 중 내부 오류 발생",
+            "details": str(e)
+        }), 500
 
 @app.route('/api/upload', methods=['POST'])
 def upload_document():

app_gradio.py

@@ -1,11 +1,19 @@
 import os
 import gradio as gr
-import requests
 import json
+import logging
+from app.app import app as flask_app  # Flask 앱 가져오기
+from flask import json as flask_json
 
-# Flask 앱은 더 이상 테스트 클라이언트로 사용하지 않음
-# 대신, localhost:7860에서 실행 중인 Flask 엔드포인트에 HTTP 요청을 보냄
-BASE_URL = "http://localhost:7860"
+# 로거 설정
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+# Flask 테스트 클라이언트 초기화
+flask_client = flask_app.test_client()
 
 # Gradio 인터페이스 생성
 with gr.Blocks(title="RAG 검색 챗봇 with 음성인식", theme=gr.themes.Soft()) as demo:
@@ -39,44 +47,57 @@ with gr.Blocks(title="RAG 검색 챗봇 with 음성인식", theme=gr.themes.Soft
         if not query:
             return "질문을 입력하세요.", ""
         try:
-            response = requests.post(f"{BASE_URL}/api/chat", json={"query": query})
-            response.raise_for_status()
-            data = response.json()
+            logger.info("텍스트 챗 요청: /api/chat")
+            response = flask_client.post("/api/chat", json={"query": query})
+            data = flask_json.loads(response.data)
             if "error" in data:
+                logger.error(f"텍스트 챗 오류: {data['error']}")
                 return data["error"], ""
             return data["answer"], json.dumps(data["sources"], indent=2)
-        except requests.RequestException as e:
-            return f"요청 중 오류 발생: {str(e)}", ""
+        except Exception as e:
+            logger.error(f"텍스트 챗 처리 실패: {str(e)}")
+            return f"처리 중 오류 발생: {str(e)}", ""
 
     # 음성 챗 기능
     def handle_voice_chat(audio_file):
         if not audio_file:
             return "음성을 업로드하세요.", "", ""
         try:
+            logger.info("음성 챗 요청: /api/voice")
             with open(audio_file, "rb") as f:
-                response = requests.post(f"{BASE_URL}/api/voice", files={"audio": f})
-            response.raise_for_status()
-            data = response.json()
+                # Flask 테스트 클라이언트는 files 직접 지원 안 하므로, 데이터를 읽어 전달
+                response = flask_client.post(
+                    "/api/voice",
+                    data={"audio": (f, "audio_file")}
+                )
+            data = flask_json.loads(response.data)
             if "error" in data:
+                logger.error(f"음성 챗 오류: {data['error']}")
                 return "", data["error"], ""
             return data["transcription"], data["answer"], json.dumps(data["sources"], indent=2)
-        except requests.RequestException as e:
-            return "", f"요청 중 오류 발생: {str(e)}", ""
+        except Exception as e:
+            logger.error(f"음성 챗 처리 실패: {str(e)}")
+            return "", f"처리 중 오류 발생: {str(e)}", ""
 
     # 문서 업로드 기능
     def handle_doc_upload(doc_file):
         if not doc_file:
             return "문서를 업로드하세요."
         try:
+            logger.info("문서 업로드 요청: /api/upload")
             with open(doc_file, "rb") as f:
-                response = requests.post(f"{BASE_URL}/api/upload", files={"document": f})
-            response.raise_for_status()
-            data = response.json()
+                response = flask_client.post(
+                    "/api/upload",
+                    data={"document": (f, "document_file")}
+                )
+            data = flask_json.loads(response.data)
             if "error" in data:
+                logger.error(f"문서 업로드 오류: {data['error']}")
                 return data["error"]
             return data["message"]
-        except requests.RequestException as e:
-            return f"요청 중 오류 발생: {str(e)}"
+        except Exception as e:
+            logger.error(f"문서 업로드 처리 실패: {str(e)}")
+            return f"처리 중 오류 발생: {str(e)}"
 
     # 이벤트 핸들러 연결
     text_button.click(