Update app.py

app.py

@@ -5,34 +5,34 @@ import json
 import time
 from dotenv import load_dotenv
 
-# .env 파일 로드 (있는 경우)
+# Load .env file (if it exists)
 load_dotenv()
 
 def create_deepseek_interface():
-    # 환경 변수에서 API 키 가져오기
+    # Get API keys from environment variables
     api_key = os.getenv("FW_API_KEY")
     serphouse_api_key = os.getenv("SERPHOUSE_API_KEY")
     
     if not api_key:
-        print("경고: FW_API_KEY 환경 변수가 설정되지 않았습니다.")
+        print("Warning: FW_API_KEY environment variable is not set.")
     if not serphouse_api_key:
-        print("경고: SERPHOUSE_API_KEY 환경 변수가 설정되지 않았습니다.")
+        print("Warning: SERPHOUSE_API_KEY environment variable is not set.")
     
-    # 키워드 추출 함수 (LLM 기반)
+    # Keyword extraction function (LLM-based)
     def extract_keywords_with_llm(query):
         if not api_key:
-            return "LLM 키워드 추출을 위한 FW_API_KEY가 설정되지 않았습니다.", query
+            return "FW_API_KEY not set for LLM keyword extraction.", query
         
-        # LLM을 사용하여 키워드 추출 (DeepSeek 모델 사용)
+        # Extract keywords using LLM (DeepSeek model)
         url = "https://api.fireworks.ai/inference/v1/chat/completions"
         payload = {
             "model": "accounts/fireworks/models/deepseek-v3-0324",
             "max_tokens": 200,
-            "temperature": 0.1,  # 일관된 결과를 위해 낮은 온도 사용
+            "temperature": 0.1,  # Low temperature for consistent results
             "messages": [
                 {
                     "role": "system",
-                    "content": "사용자의 질문에서 웹 검색에 효과적인 핵심 키워드를 추출하세요. 키워드 사이에 쉼표나 공백을 넣지 말고 하나의 검색어처럼 수정해서 제공하세요. 예를 들어 '한덕수 국무총리 탄핵 결과'처럼 공백으로만 구분하세요."
+                    "content": "Extract key search terms from the user's question that would be effective for web searches. Provide these as a search query with words separated by spaces only, without commas. For example: 'Prime Minister Han Duck-soo impeachment results'"
                 },
                 {
                     "role": "user",
@@ -51,41 +51,41 @@ def create_deepseek_interface():
             response.raise_for_status()
             result = response.json()
             
-            # 응답에서 키워드 추출
+            # Extract keywords from response
             keywords = result["choices"][0]["message"]["content"].strip()
             
-            # 키워드가 너무 길거나 형식이 잘못된 경우 원본 쿼리 사용
+            # Use original query if keywords are too long or improperly formatted
             if len(keywords) > 100:
-                return f"추출된 키워드: {keywords}", query
+                return f"Extracted keywords: {keywords}", query
                 
-            return f"추출된 키워드: {keywords}", keywords
+            return f"Extracted keywords: {keywords}", keywords
             
         except Exception as e:
-            print(f"키워드 추출 중 오류 발생: {str(e)}")
-            return f"키워드 추출 중 오류 발생: {str(e)}", query
+            print(f"Error during keyword extraction: {str(e)}")
+            return f"Error during keyword extraction: {str(e)}", query
     
-    # SerpHouse API를 사용하여 검색 수행 함수
+    # Search function using SerpHouse API
     def search_with_serphouse(query):
         if not serphouse_api_key:
-            return "SERPHOUSE_API_KEY가 설정되지 않았습니다."
+            return "SERPHOUSE_API_KEY is not set."
         
         try:
-            # 키워드 추출
+            # Extract keywords
             extraction_result, search_query = extract_keywords_with_llm(query)
-            print(f"원본 쿼리: {query}")
+            print(f"Original query: {query}")
             print(extraction_result)
             
-            # 문서 코드를 더 자세히 분석해 보니 기본 GET 방식 활용이 좋을 것 같습니다
+            # Basic GET method seems best after analyzing documentation
             url = "https://api.serphouse.com/serp/live"
             
-            # 한글 검색어인지 확인
+            # Check if query is in Korean
             is_korean = any('\uAC00' <= c <= '\uD7A3' for c in search_query)
             
-            # 간소화된 파라미터로 시도
+            # Simplified parameters
             params = {
                 "q": search_query,
                 "domain": "google.com",
-                "serp_type": "web",  # 기본 웹 검색으로 변경
+                "serp_type": "web",  # Changed to basic web search
                 "device": "desktop",
                 "lang": "ko" if is_korean else "en"
             }
@@ -94,138 +94,138 @@ def create_deepseek_interface():
                 "Authorization": f"Bearer {serphouse_api_key}"
             }
             
-            print(f"SerpHouse API 호출 중... 기본 GET 방식으로 시도")
-            print(f"검색어: {search_query}")
-            print(f"요청 URL: {url} - 파라미터: {params}")
+            print(f"Calling SerpHouse API with basic GET method...")
+            print(f"Search term: {search_query}")
+            print(f"Request URL: {url} - Parameters: {params}")
             
-            # GET 요청 수행
+            # Execute GET request
             response = requests.get(url, headers=headers, params=params)
             response.raise_for_status()
             
-            print(f"SerpHouse API 응답 상태 코드: {response.status_code}")
+            print(f"SerpHouse API response status code: {response.status_code}")
             search_results = response.json()
             
-            # 응답 구조 확인
-            print(f"응답 구조: {list(search_results.keys()) if isinstance(search_results, dict) else '딕셔너리 아님'}")
+            # Check response structure
+            print(f"Response structure: {list(search_results.keys()) if isinstance(search_results, dict) else 'Not a dictionary'}")
             
-            # 검색 결과 파싱 및 포맷팅 (Markdown 형식으로 출력)
+            # Parse and format search results (in Markdown)
             formatted_results = []
-            formatted_results.append(f"## 검색어: {search_query}\n\n")
+            formatted_results.append(f"## Search term: {search_query}\n\n")
             
-            # 다양한 가능한 응답 구조에 대한 처리
+            # Handle various possible response structures
             organic_results = None
             
-            # 가능한 응답 구조 1
+            # Possible response structure 1
             if "results" in search_results and "organic" in search_results["results"]:
                 organic_results = search_results["results"]["organic"]
                 
-            # 가능한 응답 구조 2
+            # Possible response structure 2
             elif "organic" in search_results:
                 organic_results = search_results["organic"]
                 
-            # 가능한 응답 구조 3 (중첩된 results)
+            # Possible response structure 3 (nested results)
             elif "results" in search_results and "results" in search_results["results"]:
                 if "organic" in search_results["results"]["results"]:
                     organic_results = search_results["results"]["results"]["organic"]
             
-            # organic_results가 있으면 처리
+            # Process organic results if available
             if organic_results and len(organic_results) > 0:
-                # 응답 구조 출력
-                print(f"첫번째 organic 결과 구조: {organic_results[0].keys() if len(organic_results) > 0 else 'empty'}")
+                # Output response structure
+                print(f"First organic result structure: {organic_results[0].keys() if len(organic_results) > 0 else 'empty'}")
                 
-                for i, result in enumerate(organic_results[:5], 1):  # 상위 5개 결과만 표시
-                    title = result.get("title", "제목 없음")
-                    snippet = result.get("snippet", "내용 없음")
+                for i, result in enumerate(organic_results[:5], 1):  # Show only top 5 results
+                    title = result.get("title", "No title")
+                    snippet = result.get("snippet", "No content")
                     link = result.get("link", "#")
                     displayed_link = result.get("displayed_link", link)
                     
-                    # Markdown 형식으로 출력 (번호 및 링크 포함)
+                    # Format in Markdown (including number and link)
                     formatted_results.append(
                         f"### {i}. [{title}]({link})\n\n"
                         f"{snippet}\n\n"
-                        f"**출처**: [{displayed_link}]({link})\n\n"
+                        f"**Source**: [{displayed_link}]({link})\n\n"
                         f"---\n\n"
                     )
                 
-                print(f"검색 결과 {len(organic_results)}개 찾음")
+                print(f"Found {len(organic_results)} search results")
                 return "".join(formatted_results)
             
-            # 결과가 없거나 예상치 못한 구조인 경우
-            print("검색 결과 없음 또는 예상치 못한 응답 구조")
-            print(f"응답 구조 상세: {search_results.keys() if hasattr(search_results, 'keys') else '불명확한 구조'}")
+            # Handle case with no results or unexpected structure
+            print("No search results or unexpected response structure")
+            print(f"Detailed response structure: {search_results.keys() if hasattr(search_results, 'keys') else 'Unclear structure'}")
             
-            # 응답 내용에서 오류 메시지 찾기
-            error_msg = "검색 결과가 없거나 응답 형식이 예상과 다릅니다"
+            # Find error messages in response
+            error_msg = "No search results found or response format is different than expected"
             if "error" in search_results:
                 error_msg = search_results["error"]
             elif "message" in search_results:
                 error_msg = search_results["message"]
                 
-            return f"## 검색어 '{search_query}'에 대한 결과\n\n{error_msg}"
+            return f"## Results for '{search_query}'\n\n{error_msg}"
             
         except Exception as e:
-            error_msg = f"검색 중 오류 발생: {str(e)}"
+            error_msg = f"Error during search: {str(e)}"
             print(error_msg)
             import traceback
             print(traceback.format_exc())
             
-            # 디버깅 목적으로 API 요청 상세 정보 추가 (Markdown 형식)
-            return f"## 오류 발생\n\n" + \
-                   f"검색 중 오류가 발생했습니다: **{str(e)}**\n\n" + \
-                   f"### API 요청 상세 정보:\n" + \
+            # Add API request details for debugging (in Markdown)
+            return f"## Error Occurred\n\n" + \
+                   f"An error occurred during search: **{str(e)}**\n\n" + \
+                   f"### API Request Details:\n" + \
                    f"- **URL**: {url}\n" + \
-                   f"- **검색어**: {search_query}\n" + \
-                   f"- **파라미터**: {params}\n"
+                   f"- **Search Term**: {search_query}\n" + \
+                   f"- **Parameters**: {params}\n"
     
-    # 스트리밍 방식으로 DeepSeek API 호출 함수
+    # Function to call DeepSeek API with streaming
     def query_deepseek_streaming(message, history, use_deep_research):
         if not api_key:
-            yield history, "환경 변수 FW_API_KEY가 설정되지 않았습니다. 서버에서 환경 변수를 확인해주세요."
+            yield history, "Environment variable FW_API_KEY is not set. Please check the environment variables on the server."
             return
         
         search_context = ""
         search_info = ""
         if use_deep_research:
             try:
-                # 검색 수행 (첫 메시지 전달)
-                yield history + [(message, "🔍 최적의 키워드 추출 및 웹 검색 중...")], ""
+                # Start search (first message)
+                yield history + [(message, "🔍 Extracting optimal keywords and searching the web...")], ""
                 
-                # 검색 실행 - 디버깅을 위한 로그 추가
-                print(f"Deep Research 활성화됨: 메시지 '{message}'에 대한 검색 시작")
+                # Execute search - add logs for debugging
+                print(f"Deep Research activated: Starting search for '{message}'")
                 search_results = search_with_serphouse(message)
-                print(f"검색 결과 수신 완료: {search_results[:100]}...")  # 결과 앞부분만 출력
+                print(f"Search results received: {search_results[:100]}...")  # Output first part of results
                 
-                if not search_results.startswith("검색 중 오류 발생") and not search_results.startswith("SERPHOUSE_API_KEY"):
+                if not search_results.startswith("Error during search") and not search_results.startswith("SERPHOUSE_API_KEY"):
                     search_context = f"""
-다음은 사용자 질문과 관련된 최신 검색 결과입니다. 이 정보를 참고하여 정확하고 최신 정보가 반영된 응답을 제공하세요:
+Here are recent search results related to the user's question. Use this information to provide an accurate response with the latest information:
 
 {search_results}
 
-위 검색 결과를 기반으로 사용자의 다음 질문에 답변하세요. 검색 결과에서 명확한 답변을 찾을 수 없는 경우, 당신의 지식을 활용하여 최선의 답변을 제공하세요.
-검색 결과를 인용할 때는 출처를 명시하고, 답변이 최신 정보를 반영하도록 하세요.
+Based on the above search results, answer the user's question. If you cannot find a clear answer in the search results, use your knowledge to provide the best answer.
+When citing search results, mention the source, and ensure your answer reflects the latest information.
 """
-                    search_info = f"🔍 Deep Research 기능 활성화: 관련 웹 검색 결과를 기반으로 응답 생성 중..."
+                    search_info = f"🔍 Deep Research feature activated: Generating response based on relevant web search results..."
                 else:
-                    print(f"검색 실패 또는 결과 없음: {search_results}")
+                    print(f"Search failed or no results: {search_results}")
             except Exception as e:
-                print(f"Deep Research 처리 중 예외 발생: {str(e)}")
-                search_info = f"🔍 Deep Research 기능 오류: {str(e)}"
+                print(f"Exception occurred during Deep Research: {str(e)}")
+                search_info = f"🔍 Deep Research feature error: {str(e)}"
         
-        # API 요청을 위한 대화 기록 준비
+        # Prepare conversation history for API request
         messages = []
         for user, assistant in history:
             messages.append({"role": "user", "content": user})
             messages.append({"role": "assistant", "content": assistant})
         
-        # 검색 컨텍스트가 있으면 시스템 메시지 추가
+        # Add system message with search context if available
         if search_context:
-            # DeepSeek 모델은 시스템 메시지를 지원합니다
+            # DeepSeek model supports system messages
             messages.insert(0, {"role": "system", "content": search_context})
         
-        # 새 사용자 메시지 추가
+        # Add new user message
         messages.append({"role": "user", "content": message})
         
-        # API 요청 준비
+        # Prepare API request
         url = "https://api.fireworks.ai/inference/v1/chat/completions"
         payload = {
             "model": "accounts/fireworks/models/deepseek-v3-0324",
@@ -236,7 +236,7 @@ def create_deepseek_interface():
             "frequency_penalty": 0,
             "temperature": 0.6,
             "messages": messages,
-            "stream": True  # 스트리밍 활성화
+            "stream": True  # Enable streaming
         }
         headers = {
             "Accept": "application/json",
@@ -245,123 +245,123 @@ def create_deepseek_interface():
         }
         
         try:
-            # 스트리밍 응답 요청
+            # Request streaming response
             response = requests.request("POST", url, headers=headers, data=json.dumps(payload), stream=True)
-            response.raise_for_status()  # HTTP 오류 발생 시 예외 발생
+            response.raise_for_status()  # Raise exception for HTTP errors
             
-            # 메시지를 추가하고 초기 응답으로 시작
+            # Add message and start with initial response
             new_history = history.copy()
             
-            # search_info가 있으면 시작 메시지에 포함
+            # Include search_info in starting message if available
             start_msg = search_info if search_info else ""
             new_history.append((message, start_msg))
             
-            # 응답 전체 텍스트
+            # Full response text
             full_response = start_msg
             
-            # 스트리밍 응답 처리
+            # Process streaming response
             for line in response.iter_lines():
                 if line:
                     line_text = line.decode('utf-8')
                     
-                    # 'data: ' 접두사 제거
+                    # Remove 'data: ' prefix
                     if line_text.startswith("data: "):
                         line_text = line_text[6:]
                     
-                    # 스트림 종료 메시지 확인
+                    # Check for stream end message
                     if line_text == "[DONE]":
                         break
                     
                     try:
-                        # JSON 파싱
+                        # Parse JSON
                         chunk = json.loads(line_text)
                         chunk_content = chunk.get("choices", [{}])[0].get("delta", {}).get("content", "")
                         
                         if chunk_content:
                             full_response += chunk_content
-                            # 채팅 기록 업데이트
+                            # Update chat history
                             new_history[-1] = (message, full_response)
                             yield new_history, ""
                     except json.JSONDecodeError:
                         continue
             
-            # 최종 응답 반환
+            # Return final response
             yield new_history, ""
             
         except requests.exceptions.RequestException as e:
-            error_msg = f"API 오류: {str(e)}"
+            error_msg = f"API error: {str(e)}"
             if hasattr(e, 'response') and e.response and e.response.status_code == 401:
-                error_msg = "인증 실패. 환경 변수 FW_API_KEY를 확인해주세요."
+                error_msg = "Authentication failed. Please check your FW_API_KEY environment variable."
             yield history, error_msg
     
-    # Gradio 인터페이스 생성
+    # Create Gradio interface
     with gr.Blocks(theme="soft", fill_height=True) as demo:
-        # 헤더 섹션
+        # Header section
         gr.Markdown(
             """
-            # 🤖 DeepSeek V3-0324 + Reserach 
-            ### DeepSeek V3-0324 최신 모델 + 실시간 'Deep Research' Agentic AI 시스템 @ https://discord.gg/openfreeai
+            # 🤖 DeepSeek V3-0324 + Research 
+            ### DeepSeek V3-0324 Latest Model + Real-time 'Deep Research' Agentic AI System @ https://discord.gg/openfreeai
             """
         )
         
-        # 메인 레이아웃
+        # Main layout
         with gr.Row():
-            # 메인 콘텐츠 영역
+            # Main content area
             with gr.Column():
-                # 채팅 인터페이스
+                # Chat interface
                 chatbot = gr.Chatbot(
                     height=500,
                     show_label=False,
                     container=True
                 )
                 
-                # Deep Research 토글 및 상태 표시 추가
+                # Add Deep Research toggle and status display
                 with gr.Row():
                     with gr.Column(scale=3):
                         use_deep_research = gr.Checkbox(
-                            label="Deep Research 활성화",
-                            info="최적의 키워드 추출 및 웹 검색을 통한 최신 정보 활용",
+                            label="Enable Deep Research",
+                            info="Utilize optimal keyword extraction and web search for latest information",
                             value=False
                         )
                     with gr.Column(scale=1):
-                        api_status = gr.Markdown("API 상태: 준비됨")
+                        api_status = gr.Markdown("API Status: Ready")
                 
-                # API 키 상태 확인 및 표시
+                # Check and display API key status
                 if not serphouse_api_key:
-                    api_status.value = "⚠️ SERPHOUSE_API_KEY가 설정되지 않았습니다"
+                    api_status.value = "⚠️ SERPHOUSE_API_KEY is not set"
                 if not api_key:
-                    api_status.value = "⚠️ FW_API_KEY가 설정되지 않았습니다"
+                    api_status.value = "⚠️ FW_API_KEY is not set"
                 if api_key and serphouse_api_key:
-                    api_status.value = "✅ API 키 설정 완료"
+                    api_status.value = "✅ API keys configured"
                 
-                # 입력 영역
+                # Input area
                 with gr.Row():
                     msg = gr.Textbox(
-                        label="메시지",
-                        placeholder="여기에 프롬프트를 입력하세요...",
+                        label="Message",
+                        placeholder="Enter your prompt here...",
                         show_label=False,
                         scale=9
                     )
-                    submit = gr.Button("전송", variant="primary", scale=1)
+                    submit = gr.Button("Send", variant="primary", scale=1)
                 
-                # 대화 초기화 버튼
+                # Clear conversation button
                 with gr.Row():
-                    clear = gr.ClearButton([msg, chatbot], value="🧹 대화 초기화")
+                    clear = gr.ClearButton([msg, chatbot], value="🧹 Clear Conversation")
                     
-                # 예제 쿼리
+                # Example queries
                 gr.Examples(
                     examples=[
-                        "딥러닝에서 트랜스포머와 RNN의 차이점을 설명해주세요.",
-                        "특정 범위 내의 소수를 찾는 파이썬 함수를 작성해주세요.",
-                        "강화학습의 주요 개념을 요약해주세요."
+                        "Explain the difference between Transformers and RNNs in deep learning.",
+                        "Write a Python function to find prime numbers within a specific range.",
+                        "Summarize the key concepts of reinforcement learning."
                     ],
                     inputs=msg
                 )
                 
-                # 오류 메시지 표시
+                # Error message display
                 error_box = gr.Markdown("")
         
-        # 버튼과 기능 연결
+        # Connect buttons to functions
         submit.click(
             query_deepseek_streaming,
             inputs=[msg, chatbot, use_deep_research],
@@ -372,7 +372,7 @@ def create_deepseek_interface():
             [msg]
         )
         
-        # Enter 키 제출 허용
+        # Allow Enter key submission
         msg.submit(
             query_deepseek_streaming,
             inputs=[msg, chatbot, use_deep_research],
@@ -385,7 +385,7 @@ def create_deepseek_interface():
         
     return demo
 
-# 인터페이스 실행
+# Run interface
 if __name__ == "__main__":
     demo = create_deepseek_interface()
     demo.launch(debug=True)