Update app.py

app.py

@@ -1,1491 +1,49 @@
-import os, json, re, logging, requests, markdown, time, io
-from datetime import datetime
-import random
-import base64
-from io import BytesIO
-from PIL import Image
+import os
 import sys
 import streamlit as st
-from openai import OpenAI
-
-from gradio_client import Client
-import pandas as pd
-import PyPDF2  # For handling PDF files
-import kagglehub
-
-# ──────────────────────────────── Environment Variables / Constants ─────────────────────────
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")  
-BRAVE_KEY      = os.getenv("SERPHOUSE_API_KEY", "")  # Keep this name
-BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
-BRAVE_VIDEO_ENDPOINT = "https://api.search.brave.com/res/v1/videos/search"
-BRAVE_NEWS_ENDPOINT  = "https://api.search.brave.com/res/v1/news/search"
-IMAGE_API_URL  = "http://211.233.58.201:7896"
-MAX_TOKENS     = 7999
-KAGGLE_API_KEY = os.getenv("KDATA_API", "")
-
-# Set Kaggle API key
-os.environ["KAGGLE_KEY"] = KAGGLE_API_KEY
-
-# Analysis modes and style definitions
-ANALYSIS_MODES = {
-    "price_forecast": "농산물 가격 예측과 시장 분석",
-    "market_trend": "시장 동향 및 수요 패턴 분석",
-    "production_analysis": "생산량 분석 및 식량 안보 전망",
-    "agricultural_policy": "농업 정책 및 규제 영향 분석",
-    "climate_impact": "기후 변화가 농업에 미치는 영향 분석"
-}
-
-RESPONSE_STYLES = {
-    "professional": "전문적이고 학술적인 분석",
-    "simple": "쉽게 이해할 수 있는 간결한 설명",
-    "detailed": "상세한 통계 기반 깊이 있는 분석",
-    "action_oriented": "실행 가능한 조언과 추천 중심"
-}
-
-# Example search queries
-EXAMPLE_QUERIES = {
-    "example1": "쌀 가격 추세 및 향후 6개월 전망을 분석해주세요",
-    "example2": "기후 변화로 한국 과일 생산 전략과 수요 예측 보고서를 작성하라.",
-    "example3": "2025년부터 2030년까지 충북 증평군에서 재배하면 유망한 작물은? 수익성과 관리성이 좋아야한다"
-}
-
-# ──────────────────────────────── Logging ────────────────────────────────
-logging.basicConfig(level=logging.INFO,
-                    format="%(asctime)s - %(levelname)s - %(message)s")
-
-# ──────────────────────────────── OpenAI Client ──────────────────────────
-
-@st.cache_resource
-def get_openai_client():
-    if not OPENAI_API_KEY:
-        raise RuntimeError("OPENAI_API_KEY 환경 변수가 설정되지 않았습니다.")
-    return OpenAI(
-        api_key=OPENAI_API_KEY,
-        timeout=60.0,
-        max_retries=3
-    )
-
-# ────────────────────────────── Kaggle Dataset Access ──────────────────────
-@st.cache_resource
-def load_agriculture_dataset():
-
-    try:
-        path = kagglehub.dataset_download("unitednations/global-food-agriculture-statistics")
-        logging.info(f"Kaggle dataset downloaded to: {path}")
-        
-        # Load metadata about available files
-        available_files = []
-        for root, dirs, files in os.walk(path):
-            for file in files:
-                if file.endswith('.csv'):
-                    file_path = os.path.join(root, file)
-                    file_size = os.path.getsize(file_path) / (1024 * 1024)  # Size in MB
-                    available_files.append({
-                        'name': file,
-                        'path': file_path,
-                        'size_mb': round(file_size, 2)
-                    })
-        
-        return {
-            'base_path': path,
-            'files': available_files
-        }
-    except Exception as e:
-        logging.error(f"Error loading Kaggle dataset: {e}")
-        return None
-
-# New function to load Advanced Soybean Agricultural Dataset
-@st.cache_resource
-def load_soybean_dataset():
-
-    try:
-        path = kagglehub.dataset_download("wisam1985/advanced-soybean-agricultural-dataset-2025")
-        logging.info(f"Soybean dataset downloaded to: {path}")
-        
-        available_files = []
-        for root, dirs, files in os.walk(path):
-            for file in files:
-                if file.endswith(('.csv', '.xlsx')):
-                    file_path = os.path.join(root, file)
-                    file_size = os.path.getsize(file_path) / (1024 * 1024)  # Size in MB
-                    available_files.append({
-                        'name': file,
-                        'path': file_path,
-                        'size_mb': round(file_size, 2)
-                    })
-        
-        return {
-            'base_path': path,
-            'files': available_files
-        }
-    except Exception as e:
-        logging.error(f"Error loading Soybean dataset: {e}")
-        return None
-
-# Function to load Crop Recommendation Dataset
-@st.cache_resource
-def load_crop_recommendation_dataset():
-
-    try:
-        path = kagglehub.dataset_download("agriinnovate/agricultural-crop-dataset")
-        logging.info(f"Crop recommendation dataset downloaded to: {path}")
-        
-        available_files = []
-        for root, dirs, files in os.walk(path):
-            for file in files:
-                if file.endswith(('.csv', '.xlsx')):
-                    file_path = os.path.join(root, file)
-                    file_size = os.path.getsize(file_path) / (1024 * 1024)  # Size in MB
-                    available_files.append({
-                        'name': file,
-                        'path': file_path,
-                        'size_mb': round(file_size, 2)
-                    })
-        
-        return {
-            'base_path': path,
-            'files': available_files
-        }
-    except Exception as e:
-        logging.error(f"Error loading Crop recommendation dataset: {e}")
-        return None
-
-# Function to load Climate Change Impact Dataset
-@st.cache_resource
-def load_climate_impact_dataset():
+from tempfile import NamedTemporaryFile
 
+def main():
     try:
-        path = kagglehub.dataset_download("waqi786/climate-change-impact-on-agriculture")
-        logging.info(f"Climate impact dataset downloaded to: {path}")
+        # Get the code from secrets
+        code = os.environ.get("MAIN_CODE")
         
-        available_files = []
-        for root, dirs, files in os.walk(path):
-            for file in files:
-                if file.endswith(('.csv', '.xlsx')):
-                    file_path = os.path.join(root, file)
-                    file_size = os.path.getsize(file_path) / (1024 * 1024)  # Size in MB
-                    available_files.append({
-                        'name': file,
-                        'path': file_path,
-                        'size_mb': round(file_size, 2)
-                    })
+        if not code:
+            st.error("⚠️ The application code wasn't found in secrets. Please add the MAIN_CODE secret.")
+            return
         
-        return {
-            'base_path': path,
-            'files': available_files
-        }
-    except Exception as e:
-        logging.error(f"Error loading Climate impact dataset: {e}")
-        return None
-
-def get_dataset_summary():
-
-    dataset_info = load_agriculture_dataset()
-    if not dataset_info:
-        return "Failed to load the UN global food and agriculture statistics dataset."
-    
-    summary = "# UN 글로벌 식량 및 농업 통계 데이터셋\n\n"
-    summary += f"총 {len(dataset_info['files'])}개의 CSV 파일이 포함되어 있습니다.\n\n"
-    
-    # List files with sizes
-    summary += "## 사용 가능한 데이터 파일:\n\n"
-    for i, file_info in enumerate(dataset_info['files'][:10], 1):  # Limit to first 10 files
-        summary += f"{i}. **{file_info['name']}** ({file_info['size_mb']} MB)\n"
-    
-    if len(dataset_info['files']) > 10:
-        summary += f"\n...외 {len(dataset_info['files']) - 10}개 파일\n"
-    
-    # Add example of data structure
-    try:
-        if dataset_info['files']:
-            sample_file = dataset_info['files'][0]['path']
-            df = pd.read_csv(sample_file, nrows=5)
-            summary += "\n## 데이터 샘플 구조:\n\n"
-            summary += df.head(5).to_markdown() + "\n\n"
-            
-            summary += "## 데이터셋 변수 설명:\n\n"
-            for col in df.columns:
-                summary += f"- **{col}**: [변수 설명 필요]\n"
-    except Exception as e:
-        logging.error(f"Error generating dataset sample: {e}")
-        summary += "\n데이터 샘플을 생성하는 중 오류가 발생했습니다.\n"
-    
-    return summary
-
-def analyze_dataset_for_query(query):
-
-    dataset_info = load_agriculture_dataset()
-    if not dataset_info:
-        return "데이터셋을 불러올 수 없습니다. Kaggle API 연결을 확인해주세요."
-    
-    # Extract key terms from the query
-    query_lower = query.lower()
-    
-    # Define keywords to look for in the dataset files
-    keywords = {
-        "쌀": ["rice", "grain"],
-        "밀": ["wheat", "grain"],
-        "옥수수": ["corn", "maize", "grain"],
-        "채소": ["vegetable", "produce"],
-        "과일": ["fruit", "produce"],
-        "가격": ["price", "cost", "value"],
-        "생산": ["production", "yield", "harvest"],
-        "수출": ["export", "trade"],
-        "수입": ["import", "trade"],
-        "소비": ["consumption", "demand"]
-    }
-    
-    # Find relevant files based on the query
-    relevant_files = []
-    
-    # First check for Korean keywords in the query
-    found_keywords = []
-    for k_term, e_terms in keywords.items():
-        if k_term in query_lower:
-            found_keywords.extend([k_term] + e_terms)
-    
-    # If no Korean keywords found, check for English terms in the filenames
-    if not found_keywords:
-        # Generic search through all files
-        relevant_files = dataset_info['files'][:5]  # Take first 5 files as default
-    else:
-        # Search for files related to the found keywords
-        for file_info in dataset_info['files']:
-            file_name_lower = file_info['name'].lower()
-            for keyword in found_keywords:
-                if keyword.lower() in file_name_lower:
-                    relevant_files.append(file_info)
-                    break
-        
-        # If still no relevant files, take the first 5 files
-        if not relevant_files:
-            relevant_files = dataset_info['files'][:5]
-    
-    # Read and analyze the relevant files
-    analysis_result = "# 농업 데이터 분석 결과\n\n"
-    analysis_result += f"쿼리: '{query}'에 대한 분석을 수행했습니다.\n\n"
-    
-    if found_keywords:
-        analysis_result += f"## 분석 키워드: {', '.join(set(found_keywords))}\n\n"
-    
-    # Process each relevant file
-    for file_info in relevant_files[:3]:  # Limit to 3 files for performance
+        # Try to fix any potential string issues
         try:
-            analysis_result += f"## 파일: {file_info['name']}\n\n"
-            
-            # Read the CSV file
-            df = pd.read_csv(file_info['path'])
-            
-            # Basic file stats
-            analysis_result += f"- 행 수: {len(df)}\n"
-            analysis_result += f"- 열 수: {len(df.columns)}\n"
-            analysis_result += f"- 열 목록: {', '.join(df.columns.tolist())}\n\n"
+            # Just to verify the code is syntactically valid before writing to file
+            compile(code, '<string>', 'exec')
+        except SyntaxError as e:
+            st.error(f"⚠️ Syntax error in the application code: {str(e)}")
+            st.info("Please check your code for unterminated strings or other syntax errors.")
             
-            # Sample data
-            analysis_result += "### 데이터 샘플:\n\n"
-            analysis_result += df.head(5).to_markdown() + "\n\n"
-            
-            # Statistical summary of numeric columns
-            numeric_cols = df.select_dtypes(include=['number']).columns
-            if len(numeric_cols) > 0:
-                analysis_result += "### 기본 통계:\n\n"
-                stats_df = df[numeric_cols].describe()
-                analysis_result += stats_df.to_markdown() + "\n\n"
-            
-            # Time series analysis if possible
-            time_cols = [col for col in df.columns if 'year' in col.lower() or 'date' in col.lower()]
-            if time_cols:
-                analysis_result += "### 시계열 패턴:\n\n"
-                analysis_result += "데이터셋에 시간 관련 열이 있어 시계열 분석이 가능합니다.\n\n"
-            
-        except Exception as e:
-            logging.error(f"Error analyzing file {file_info['name']}: {e}")
-            analysis_result += f"이 파일 분석 중 오류가 발생했습니다: {str(e)}\n\n"
-    
-    analysis_result += "## 농산물 가격 예측 및 수요 분석에 대한 인사이트\n\n"
-    analysis_result += "데이터셋에서 추출한 정보를 바탕으로 다음 인사이트를 제공합니다:\n\n"
-    analysis_result += "1. 데이터 기반 분석 (기본적인 요약)\n"
-    analysis_result += "2. 주요 가격 및 수요 동향\n"
-    analysis_result += "3. 생산량 및 무역 패턴\n\n"
-    
-    analysis_result += "이 분석은 UN 글로벌 식량 및 농업 통계 데이터셋을 기반으로 합니다.\n\n"
-    
-    return analysis_result
-
-# Function to analyze crop recommendation dataset
-def analyze_crop_recommendation_dataset(query):
-
-    try:
-        dataset_info = load_crop_recommendation_dataset()
-        if not dataset_info or not dataset_info['files']:
-            return "작물 추천 데이터셋을 불러올 수 없습니다."
+            # Show the problematic line if possible
+            if hasattr(e, 'lineno') and hasattr(e, 'text'):
+                st.code(f"Line {e.lineno}: {e.text}")
+                st.write(f"Error occurs near character position: {e.offset}")
+            return
         
-        analysis_result = "# 토양 및 환경 변수 기반 작물 추천 데이터 분석\n\n"
+        # Create a temporary Python file
+        with NamedTemporaryFile(suffix='.py', delete=False, mode='w') as tmp:
+            tmp.write(code)
+            tmp_path = tmp.name
         
-        # Process main files
-        for file_info in dataset_info['files'][:2]:  # Limit to the first 2 files
-            try:
-                analysis_result += f"## 파일: {file_info['name']}\n\n"
-                
-                if file_info['name'].endswith('.csv'):
-                    df = pd.read_csv(file_info['path'])
-                elif file_info['name'].endswith('.xlsx'):
-                    df = pd.read_excel(file_info['path'])
-                else:
-                    continue
-                
-                # Basic dataset info
-                analysis_result += f"- 데이터 크기: {len(df)} 행 × {len(df.columns)} 열\n"
-                analysis_result += f"- 포함된 작물 종류: "
-                
-                # Check if crop column exists
-                crop_cols = [col for col in df.columns if 'crop' in col.lower() or '작물' in col.lower()]
-                if crop_cols:
-                    main_crop_col = crop_cols[0]
-                    unique_crops = df[main_crop_col].unique()
-                    analysis_result += f"{len(unique_crops)}종 ({', '.join(str(c) for c in unique_crops[:10])})\n\n"
-                else:
-                    analysis_result += "작물 정보 열을 찾을 수 없음\n\n"
-                
-                # Extract environmental factors
-                env_factors = [col for col in df.columns if col.lower() not in ['crop', 'label', 'id', 'index']]
-                if env_factors:
-                    analysis_result += f"- 고려된 환경 요소: {', '.join(env_factors)}\n\n"
-                
-                # Sample data
-                analysis_result += "### 데이터 샘플:\n\n"
-                analysis_result += df.head(5).to_markdown() + "\n\n"
-                
-                # Summary statistics for environmental factors
-                if env_factors:
-                    numeric_factors = df[env_factors].select_dtypes(include=['number']).columns
-                    if len(numeric_factors) > 0:
-                        analysis_result += "### 환경 요소 통계:\n\n"
-                        stats_df = df[numeric_factors].describe().round(2)
-                        analysis_result += stats_df.to_markdown() + "\n\n"
-                
-                # Check for query-specific crops
-                query_terms = query.lower().split()
-                relevant_crops = []
-                
-                if crop_cols:
-                    for crop in df[main_crop_col].unique():
-                        crop_str = str(crop).lower()
-                        if any(term in crop_str for term in query_terms):
-                            relevant_crops.append(crop)
-                
-                if relevant_crops:
-                    analysis_result += f"### 쿼리 관련 작물 분석: {', '.join(str(c) for c in relevant_crops)}\n\n"
-                    for crop in relevant_crops[:3]:  # Limit to 3 crops
-                        crop_data = df[df[main_crop_col] == crop]
-                        analysis_result += f"#### {crop} 작물 요약:\n\n"
-                        analysis_result += f"- 샘플 수: {len(crop_data)}개\n"
-                        
-                        if len(numeric_factors) > 0:
-                            crop_stats = crop_data[numeric_factors].describe().round(2)
-                            analysis_result += f"- 평균 환경 조건:\n"
-                            for factor in numeric_factors[:5]:  # Limit to 5 factors
-                                analysis_result += f"  * {factor}: {crop_stats.loc['mean', factor]}\n"
-                        analysis_result += "\n"
-            
-            except Exception as e:
-                logging.error(f"Error analyzing crop recommendation file {file_info['name']}: {e}")
-                analysis_result += f"분석 오류: {str(e)}\n\n"
+        # Execute the code
+        exec(compile(code, tmp_path, 'exec'), globals())
         
-        analysis_result += "## 작물 추천 인사이트\n\n"
-        analysis_result += "토양 및 환경 변수 데이터셋 분석 결과, 다음과 같은 주요 인사이트를 제공합니다:\n\n"
-        analysis_result += "1. 지역 환경에 적합한 작물 추천\n"
-        analysis_result += "2. 작물 생산성에 영향을 미치는 주요 환경 요인\n"
-        analysis_result += "3. 지속 가능한 농업을 위한 최적의 작물 선택 기준\n\n"
-        
-        return analysis_result
-        
-    except Exception as e:
-        logging.error(f"Crop recommendation dataset analysis error: {e}")
-        return "작물 추천 데이터셋 분석 중 오류가 발생했습니다."
-
-# Function to analyze climate impact dataset
-def analyze_climate_impact_dataset(query):
-
-    try:
-        dataset_info = load_climate_impact_dataset()
-        if not dataset_info or not dataset_info['files']:
-            return "기후 변화 영향 데이터셋을 불러올 수 없습니다."
-        
-        analysis_result = "# 기후 변화가 농업에 미치는 영향 데이터 분석\n\n"
-        
-        # Process main files
-        for file_info in dataset_info['files'][:2]:  # Limit to first 2 files
-            try:
-                analysis_result += f"## 파일: {file_info['name']}\n\n"
-                
-                if file_info['name'].endswith('.csv'):
-                    df = pd.read_csv(file_info['path'])
-                elif file_info['name'].endswith('.xlsx'):
-                    df = pd.read_excel(file_info['path'])
-                else:
-                    continue
-                
-                # Basic dataset info
-                analysis_result += f"- 데이터 크기: {len(df)} 행 × {len(df.columns)} 열\n"
-                
-                # Check for region column
-                region_cols = [col for col in df.columns if 'region' in col.lower() or 'country' in col.lower() or '지역' in col.lower()]
-                if region_cols:
-                    main_region_col = region_cols[0]
-                    regions = df[main_region_col].unique()
-                    analysis_result += f"- 포함된 지역: {len(regions)}개 ({', '.join(str(r) for r in regions[:5])})\n"
-                
-                # Identify climate and crop related columns
-                climate_cols = [col for col in df.columns if any(term in col.lower() for term in 
-                                ['temp', 'rainfall', 'precipitation', 'climate', 'weather', '기온', '강수량'])]
-                crop_cols = [col for col in df.columns if any(term in col.lower() for term in 
-                            ['yield', 'production', 'crop', 'harvest', '수확량', '생산량'])]
-                
-                if climate_cols:
-                    analysis_result += f"- 기후 관련 변수: {', '.join(climate_cols)}\n"
-                if crop_cols:
-                    analysis_result += f"- 작물 관련 변수: {', '.join(crop_cols)}\n\n"
-                
-                # Sample data
-                analysis_result += "### 데이터 샘플:\n\n"
-                analysis_result += df.head(5).to_markdown() + "\n\n"
-                
-                # Time series pattern if available
-                year_cols = [col for col in df.columns if 'year' in col.lower() or 'date' in col.lower() or '연도' in col.lower()]
-                if year_cols:
-                    analysis_result += "### 시계열 기후 영향 패턴:\n\n"
-                    analysis_result += "이 데이터셋은 시간에 따른 기후 변화와 농업 생산성 간의 관계를 분석할 수 있습니다.\n\n"
-                
-                # Statistical summary of key variables
-                key_vars = climate_cols + crop_cols
-                numeric_vars = df[key_vars].select_dtypes(include=['number']).columns
-                if len(numeric_vars) > 0:
-                    analysis_result += "### 주요 변수 통계:\n\n"
-                    stats_df = df[numeric_vars].describe().round(2)
-                    analysis_result += stats_df.to_markdown() + "\n\n"
-                
-                # Check for correlations between climate and crop variables
-                if len(climate_cols) > 0 and len(crop_cols) > 0:
-                    numeric_climate = df[climate_cols].select_dtypes(include=['number']).columns
-                    numeric_crop = df[crop_cols].select_dtypes(include=['number']).columns
-                    
-                    if len(numeric_climate) > 0 and len(numeric_crop) > 0:
-                        analysis_result += "### 기후와 작물 생산 간의 상관관계:\n\n"
-                        try:
-                            corr_vars = list(numeric_climate)[:2] + list(numeric_crop)[:2]  # Limit to 2 of each type
-                            corr_df = df[corr_vars].corr().round(3)
-                            analysis_result += corr_df.to_markdown() + "\n\n"
-                            analysis_result += "위 상관관계 표는 기후 변수와 작물 생산성 간의 관계 강도를 보여줍니다.\n\n"
-                        except:
-                            analysis_result += "상관관계 계산 중 오류가 발생했습니다.\n\n"
-            
-            except Exception as e:
-                logging.error(f"Error analyzing climate impact file {file_info['name']}: {e}")
-                analysis_result += f"분석 오류: {str(e)}\n\n"
-        
-        analysis_result += "## 기후 변화 영향 인사이트\n\n"
-        analysis_result += "기후 변화가 농업에 미치는 영향 데이터 분석 결과, 다음과 같은 인사이트를 제공합니다:\n\n"
-        analysis_result += "1. 기온 변화에 따른 작물 생산성 변동 패턴\n"
-        analysis_result += "2. 강수량 변화가 농업 수확량에 미치는 영향\n"
-        analysis_result += "3. 기후 변화에 대응하기 위한 농업 전략 제안\n"
-        analysis_result += "4. 지역별 기후 취약성 및 적응 방안\n\n"
-        
-        return analysis_result
-        
-    except Exception as e:
-        logging.error(f"Climate impact dataset analysis error: {e}")
-        return "기후 변화 영향 데이터셋 분석 중 오류가 발생했습니다."
-
-# Function to analyze soybean dataset if selected
-def analyze_soybean_dataset(query):
-
-    try:
-        dataset_info = load_soybean_dataset()
-        if not dataset_info or not dataset_info['files']:
-            return "대두 농업 데이터셋을 불러올 수 없습니다."
-        
-        analysis_result = "# 고급 대두 농업 데이터 분석\n\n"
-        
-        # Process main files
-        for file_info in dataset_info['files'][:2]:  # Limit to the first 2 files
-            try:
-                analysis_result += f"## 파일: {file_info['name']}\n\n"
-                
-                if file_info['name'].endswith('.csv'):
-                    df = pd.read_csv(file_info['path'])
-                elif file_info['name'].endswith('.xlsx'):
-                    df = pd.read_excel(file_info['path'])
-                else:
-                    continue
-                
-                # Basic file stats
-                analysis_result += f"- 데이터 크기: {len(df)} 행 × {len(df.columns)} 열\n"
-                
-                # Check for region/location columns
-                location_cols = [col for col in df.columns if any(term in col.lower() for term in 
-                                ['region', 'location', 'area', 'country', '지역'])]
-                if location_cols:
-                    main_loc_col = location_cols[0]
-                    locations = df[main_loc_col].unique()
-                    analysis_result += f"- 포함된 지역: {len(locations)}개 ({', '.join(str(loc) for loc in locations[:5])})\n"
-                
-                # Identify yield and production columns
-                yield_cols = [col for col in df.columns if any(term in col.lower() for term in 
-                             ['yield', 'production', 'harvest', '수확량', '생산량'])]
-                if yield_cols:
-                    analysis_result += f"- 생산성 관련 변수: {', '.join(yield_cols)}\n"
-                
-                # Identify environmental factors
-                env_cols = [col for col in df.columns if any(term in col.lower() for term in 
-                           ['temp', 'rainfall', 'soil', 'fertilizer', 'nutrient', 'irrigation', 
-                            '기온', '강수량', '토양', '비료', '관개'])]
-                if env_cols:
-                    analysis_result += f"- 환경 관련 변수: {', '.join(env_cols)}\n\n"
-                
-                # Sample data
-                analysis_result += "### 데이터 샘플:\n\n"
-                analysis_result += df.head(5).to_markdown() + "\n\n"
-                
-                # Statistical summary of key variables
-                key_vars = yield_cols + env_cols
-                numeric_vars = df[key_vars].select_dtypes(include=['number']).columns
-                if len(numeric_vars) > 0:
-                    analysis_result += "### 주요 변수 통계:\n\n"
-                    stats_df = df[numeric_vars].describe().round(2)
-                    analysis_result += stats_df.to_markdown() + "\n\n"
-                
-                # Time series analysis if possible
-                year_cols = [col for col in df.columns if 'year' in col.lower() or 'date' in col.lower() or '연도' in col.lower()]
-                if year_cols:
-                    analysis_result += "### 시계열 생산성 패턴:\n\n"
-                    analysis_result += "이 데이터셋은 시간에 따른 대두 생산성의 변화를 추적할 수 있습니다.\n\n"
-                
-                # Check for correlations between environmental factors and yield
-                if len(env_cols) > 0 and len(yield_cols) > 0:
-                    numeric_env = df[env_cols].select_dtypes(include=['number']).columns
-                    numeric_yield = df[yield_cols].select_dtypes(include=['number']).columns
-                    
-                    if len(numeric_env) > 0 and len(numeric_yield) > 0:
-                        analysis_result += "### 환경 요소와 대두 생산성 간의 상관관계:\n\n"
-                        try:
-                            corr_vars = list(numeric_env)[:3] + list(numeric_yield)[:2]  # Limit variables
-                            corr_df = df[corr_vars].corr().round(3)
-                            analysis_result += corr_df.to_markdown() + "\n\n"
-                        except:
-                            analysis_result += "상관관계 계산 중 오류가 발생했습니다.\n\n"
-            
-            except Exception as e:
-                logging.error(f"Error analyzing soybean file {file_info['name']}: {e}")
-                analysis_result += f"분석 오류: {str(e)}\n\n"
-        
-        analysis_result += "## 대두 농업 인사이트\n\n"
-        analysis_result += "고급 대두 농업 데이터셋 분석 결과, 다음과 같은 인사이트를 제공합니다:\n\n"
-        analysis_result += "1. 최적의 대두 생산을 위한 환경 조건\n"
-        analysis_result += "2. 지역별 대두 생산성 변화 패턴\n"
-        analysis_result += "3. 생산성 향상을 위한 농업 기술 및 접근법\n"
-        analysis_result += "4. 시장 수요에 맞는 대두 품종 선택 가이드\n\n"
-        
-        return analysis_result
-        
-    except Exception as e:
-        logging.error(f"Soybean dataset analysis error: {e}")
-        return "대두 농업 데이터셋 분석 중 오류가 발생했습니다."
-
-# ──────────��───────────────────── System Prompt ─────────────────────────
-def get_system_prompt(mode="price_forecast", style="professional", include_search_results=True, include_uploaded_files=False) -> str:
-
-    base_prompt = """
-당신은 농업 데이터 전문가로서 농산물 가격 예측과 수요 분석을 수행하는 AI 어시스턴트입니다.
-
-주요 임무:
-1. UN 글로벌 식량 및 농업 통계 데이터셋을 기반으로 농산물 시장 분석
-2. 농산물 가격 추세 예측 및 수요 패턴 분석
-3. 데이터를 바탕으로 명확하고 근거 있는 분석 제공
-4. 관련 정보와 인사이트를 체계적으로 구성하여 제시
-5. 시각적 이해를 돕기 위해 차트, 그래프 등을 적절히 활용
-6. 토양 및 환경 변수 기반 작물 추천 데이터셋에서 추출한 인사이트 적용
-7. 기후 변화가 농업에 미치는 영향 데이터셋을 통한 환경 변화 시나리오 분석
-
-중요 가이드라인:
-- 데이터에 기반한 객관적 분석을 제공하세요
-- 분석 과정과 방법론을 명확히 설명하세요
-- 통계적 신뢰성과 한계점을 투명하게 제시하세요
-- 이해하기 쉬운 시각적 요소로 분석 결과를 보완하세요
-- 마크다운을 활용해 응답을 체계적으로 구성하세요"""
-
-    mode_prompts = {
-        "price_forecast": """
-농산물 가격 예측 및 시장 분석에 집중합니다:
-- 과거 가격 데이터 패턴에 기반한 예측 제공
-- 가격 변동성 요인 분석(계절성, 날씨, 정책 등)
-- 단기 및 중장기 가격 전망 제시
-- 가격에 영향을 미치는 국내외 요인 식별
-- 시장 불확실성과 리스크 요소 강조""",
-        
-        "market_trend": """
-시장 동향 및 수요 패턴 분석에 집중합니다:
-- 주요 농산물 수요 변화 패턴 식별
-- 소비자 선호도 및 구매 행동 분석
-- 시장 세그먼트 및 틈새시장 기회 탐색
-- 시장 확대/축소 트렌드 평가
-- 수요 탄력성 및 가격 민감도 분석""",
-        
-        "production_analysis": """
-생산량 분석 및 식량 안보 전망에 집중합니다:
-- 작물 생산량 추세 및 변동 요인 분석
-- 식량 생산과 인구 성장 간의 관계 평가
-- 국가/지역별 생산 역량 비교
-- 식량 안보 위협 요소 및 취약점 식별
-- 생산성 향상 전략 및 기회 제안""",
-        
-        "agricultural_policy": """
-농업 정책 및 규제 영향 분석에 집중합니다:
-- 정부 정책과, 보조금, 규제의 시장 영향 분석
-- 국제 무역 정책과 관세의 농산물 가격 영향 평가
-- 농업 지원 프로그램의 효과성 검토
-- 규제 환경 변화에 따른 시장 조정 예측
-- 정책적 개입의 의도된/의도치 않은 결과 분석""",
-        
-        "climate_impact": """
-기후 변화가 농업에 미치는 영향 분석에 집중합니다:
-- 기후 변화와 농산물 생산량/품질 간의 상관관계 분석
-- 기상 이변이 가격 변동성에 미치는 영향 평가
-- 장기적 기후 추세에 따른 농업 패턴 변화 예측
-- 기후 회복력 있는 농업 시스템 전략 제안
-- 지역별 기후 위험 노출도 및 취약성 매핑"""
-        
-    }
-
-    style_guides = {
-        "professional": "전문적이고 학술적인 어조를 사용하세요. 기술적 용어를 적절히 사용하고 체계적인 데이터 분석을 제공하세요.",
-        "simple": "쉽고 간결한 언어로 설명하세요. 전문 용어는 최소화하고 핵심 개념을 일상적인 표현으로 전달하세요.",
-        "detailed": "상세하고 포괄적인 분석을 제공하세요. 다양한 데이터 포인트, 통계적 뉘앙스, 그리고 여러 시나리오를 고려한 심층 분석을 제시하세요.",
-        "action_oriented": "실행 가능한 인사이트와 구체적인 권장사항에 초점을 맞추세요. '다음 단계' 및 '실질적 조언' 섹션을 포함하세요."
-    }
-
-    dataset_guide = """
-농업 데이터셋 활용 지침:
-- UN 글로벌 식량 및 농업 통계 데이터셋을 기본 분석의 근거로 사용하세요
-- 토양 및 환경 변수 기반 작물 추천 데이터셋의 인사이트를 작물 선택 및 재배 조건 분석에 통합하세요
-- 기후 변화가 농업에 미치는 영향 데이터셋의 정보를 지속 가능성 및 미래 전망 분석에 활용하세요
-- 데이터의 출처와 연도를 명확히 인용하세요
-- 데이터셋 내 주요 변수 간의 관계를 분석하여 인사이트를 도출하세요
-- 데이터의 한계와 불확실성을 투명하게 언급하세요
-- 필요시 데이터 격차를 식별하고 추가 연구가 필요한 영역을 제안하세요"""
-
-    soybean_guide = """
-고급 대두 농업 데이터셋 활용 지침:
-- 대두 생산 조건 및 수확량 패턴을 다른 작물과 비교하여 분석하세요
-- 대두 농업의 경제적 가치와 시장 기회에 대한 인사이트를 제공하세요
-- 대두 생산성에 영향을 미치는 주요 환경 요인을 강조하세요
-- 대두 재배 기술 혁신과 수익성 향상 방안을 제안하세요
-- 지속 가능한 대두 농업을 위한 실질적인 접근법을 공유하세요"""
-
-    crop_recommendation_guide = """
-토양 및 환경 변수 기반 작물 추천 활용 지침:
-- 지역 특성에 맞는 최적의 작물 선택 기준을 제시하세요
-- 토양 조건과 작물 적합성 간의 상관관계를 분석하세요
-- 환경 변수에 따른 작물 생산성 예측 모델을 활용하세요
-- 농업 생산성과 수익성 향상을 위한 작물 선택 전략을 제안하세요
-- 지속 가능한 농업을 위한 작물 다양화 접근법을 권장하세요"""
-
-    climate_impact_guide = """
-기후 변화가 농업에 미치는 영향 데이터셋 활용 지침:
-- 기후 변화 시나리오에 따른 작물 생산성 변화를 예측하세요
-- 기후 적응형 농업 기술 및 전략을 제안하세요
-- 지역별 기후 위험 요소와 대응 방안을 분석하세요
-- 기후 변화에 대응하기 위한 작물 선택 및 재배 시기 조정 방안을 제시하세요
-- 기후 변화가 농산물 가격 및 시장 동향에 미치는 영향을 평가하세요"""
-
-    search_guide = """
-웹 검색 결과 활용 지침:
-- 데이터셋 분석을 보완하는 최신 시장 정보로 검색 결과를 활용하세요
-- 각 정보의 출처를 마크다운 링크로 포함하세요: [출처명](URL)
-- 주요 주장이나 데이터 포인트마다 출처를 표시하세요
-- 출처가 상충할 경우, 다양한 관점과 신뢰도를 설명하세요
-- 관련 동영상 링크는 [비디오: 제목](video_url) 형식으로 포함하세요
-- 검색 정보를 일관되고 체계적인 응답으로 통합하세요
-- 모든 주요 출처를 나열한 "참고 자료" 섹션을 마지막에 포함하세요"""
-
-    upload_guide = """
-업로드된 파일 활용 지침:
-- 업로드된 파일을 응답의 주요 정보원으로 활용하세요
-- 쿼리와 직접 관련된 파일 정보를 추출하고 강조하세요
-- 관련 구절을 인용하고 특정 파일을 출처로 인용하세요
-- CSV 파일의 수치 데이터는 요약 문장으로 변환하세요
-- PDF 콘텐츠는 특정 섹션이나 페이지를 참조하세요
-- 파일 정보를 웹 검색 결과와 원활하게 통합하세요
-- 정보가 상충할 경우, 일반적인 웹 결과보다 파일 콘텐츠를 우선시하세요"""
-
-    # Base prompt
-    final_prompt = base_prompt
-
-    # Add mode-specific guidance
-    if mode in mode_prompts:
-        final_prompt += "\n" + mode_prompts[mode]
-
-    # Style
-    if style in style_guides:
-        final_prompt += f"\n\n분석 스타일: {style_guides[style]}"
-
-    # Always include dataset guides
-    final_prompt += f"\n\n{dataset_guide}"
-    final_prompt += f"\n\n{crop_recommendation_guide}"
-    final_prompt += f"\n\n{climate_impact_guide}"
-    
-    # Conditionally add soybean dataset guide if selected in UI
-    if st.session_state.get('use_soybean_dataset', False):
-        final_prompt += f"\n\n{soybean_guide}"
-
-    if include_search_results:
-        final_prompt += f"\n\n{search_guide}"
-
-    if include_uploaded_files:
-        final_prompt += f"\n\n{upload_guide}"
-
-    final_prompt += """
-\n\n응답 형식 요구사항:
-- 마크다운 제목(## 및 ###)을 사용하여 응답을 체계적으로 구성하세요
-- 중요한 점은 굵은 텍스트(**텍스트**)로 강조하세요
-- 3-5개의 후속 질문을 포함한 "관련 질문" 섹션을 마지막에 추가하세요
-- 적절한 간격과 단락 구분으로 응답을 서식화하세요
-- 모든 링크는 마크다운 형식으로 클릭 가능하게 만드세요: [텍스트](url)
-- 가능한 경우 데이터를 시각적으로 표현(표, 그래프 등의 설명)하세요"""
-    
-    return final_prompt
-
-# ──────────────────────────────── Brave Search API ────────────────────────
-@st.cache_data(ttl=3600)
-def brave_search(query: str, count: int = 10):
-    if not BRAVE_KEY:
-        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")
-
-    headers = {"Accept": "application/json", "Accept-Encoding": "gzip", "X-Subscription-Token": BRAVE_KEY}
-    params = {"q": query + " 농산물 가격 동향 농업 데이터", "count": str(count)}
-
-    for attempt in range(3):
+        # Clean up the temporary file
         try:
-            r = requests.get(BRAVE_ENDPOINT, headers=headers, params=params, timeout=15)
-            r.raise_for_status()
-            data = r.json()
-
-            raw = data.get("web", {}).get("results") or data.get("results", [])
-            if not raw:
-                logging.warning(f"No Brave search results found. Response: {data}")
-                raise ValueError("No search results found.")
+            os.unlink(tmp_path)
+        except:
+            pass
             
-            arts = []
-            for i, res in enumerate(raw[:count], 1):
-                url = res.get("url", res.get("link", ""))
-                host = re.sub(r"https?://(www\.)?", "", url).split("/")[0]
-                arts.append({
-                    "index": i,
-                    "title": res.get("title", "No title"),
-                    "link": url,
-                    "snippet": res.get("description", res.get("text", "No snippet")),
-                    "displayed_link": host
-                })
-
-            return arts
-
-        except Exception as e:
-            logging.error(f"Brave search failure (attempt {attempt+1}/3): {e}")
-            if attempt < 2:
-                time.sleep(5)
-
-    return []
-
-@st.cache_data(ttl=3600)
-def brave_video_search(query: str, count: int = 3):
-    if not BRAVE_KEY:
-        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")
-
-    headers = {"Accept": "application/json","Accept-Encoding": "gzip","X-Subscription-Token": BRAVE_KEY}
-    params = {"q": query + " 농산물 가격 농업 시장", "count": str(count)}
-
-    for attempt in range(3):
-        try:
-            r = requests.get(BRAVE_VIDEO_ENDPOINT, headers=headers, params=params, timeout=15)
-            r.raise_for_status()
-            data = r.json()
-
-            results = []
-            for i, vid in enumerate(data.get("results", [])[:count], 1):
-                results.append({
-                    "index": i,
-                    "title": vid.get("title", "Video"),
-                    "video_url": vid.get("url", ""),
-                    "thumbnail_url": vid.get("thumbnail", {}).get("src", ""),
-                    "source": vid.get("provider", {}).get("name", "Unknown source")
-                })
-
-            return results
-
-        except Exception as e:
-            logging.error(f"Brave video search failure (attempt {attempt+1}/3): {e}")
-            if attempt < 2:
-                time.sleep(5)
-
-    return []
-
-@st.cache_data(ttl=3600)
-def brave_news_search(query: str, count: int = 3):
-    if not BRAVE_KEY:
-        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")
-
-    headers = {"Accept": "application/json","Accept-Encoding": "gzip","X-Subscription-Token": BRAVE_KEY}
-    params = {"q": query + " 농산물 가격 동향 농업", "count": str(count)}
-
-    for attempt in range(3):
-        try:
-            r = requests.get(BRAVE_NEWS_ENDPOINT, headers=headers, params=params, timeout=15)
-            r.raise_for_status()
-            data = r.json()
-
-            results = []
-            for i, news in enumerate(data.get("results", [])[:count], 1):
-                results.append({
-                    "index": i,
-                    "title": news.get("title", "News article"),
-                    "url": news.get("url", ""),
-                    "description": news.get("description", ""),
-                    "source": news.get("source", "Unknown source"),
-                    "date": news.get("age", "Unknown date")
-                })
-
-            return results
-
-        except Exception as e:
-            logging.error(f"Brave news search failure (attempt {attempt+1}/3): {e}")
-            if attempt < 2:
-                time.sleep(5)
-
-    return []
-
-def mock_results(query: str) -> str:
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    return (f"# 대체 검색 콘텐츠 (생성 시간: {ts})\n\n"
-            f"'{query}'에 대한 검색 API 요청이 실패했거나 결과가 없습니다. "
-            f"기존 지식을 기반으로 응답을 생성해주세요.\n\n"
-            f"다음 사항을 고려하세요:\n\n"
-            f"- {query}에 관한 기본 개념과 중요성\n"
-            f"- 일반적으로 알려진 관련 통계나 추세\n"
-            f"- 이 주제에 대한 전문가 의견\n"
-            f"- 독자가 가질 수 있는 질문\n\n"
-            f"참고: 이는 실시간 데이터가 아닌 대체 지침입니다.\n\n")
-
-def do_web_search(query: str) -> str:
-    try:
-        arts = brave_search(query, 10)
-        if not arts:
-            logging.warning("No search results, using fallback content")
-            return mock_results(query)
-
-        videos = brave_video_search(query, 2)
-        news   = brave_news_search(query, 3)
-        
-        result = "# 웹 검색 결과\n다음 결과를 활용하여 데이터셋 분석을 보완하는 포괄적인 답변을 제공하세요.\n\n"
-        
-        result += "## 웹 결과\n\n"
-        for a in arts[:5]:
-            result += f"### 결과 {a['index']}: {a['title']}\n\n{a['snippet']}\n\n"
-            result += f"**출처**: [{a['displayed_link']}]({a['link']})\n\n---\n"
-        
-        if news:
-            result += "## 뉴스 결과\n\n"
-            for n in news:
-                result += f"### {n['title']}\n\n{n['description']}\n\n"
-                result += f"**출처**: [{n['source']}]({n['url']}) - {n['date']}\n\n---\n"
-                
-        if videos:
-            result += "## 비디오 결과\n\n"
-            for vid in videos:
-                result += f"### {vid['title']}\n\n"
-                if vid.get('thumbnail_url'):
-                    result += f"![썸네일]({vid['thumbnail_url']})\n\n"
-                result += f"**시청**: [{vid['source']}]({vid['video_url']})\n\n"
-        
-        return result
-        
     except Exception as e:
-        logging.error(f"Web search process failed: {str(e)}")
-        return mock_results(query)
-
-# ──────────────────────────────── File Upload Handling ─────────────────────
-def process_text_file(file):
-    try:
-        content = file.read()
-        file.seek(0)
-
-        text = content.decode('utf-8', errors='ignore')
-        if len(text) > 10000:
-            text = text[:9700] + "...(truncated)..."
-
-        result = f"## 텍스트 파일: {file.name}\n\n" + text
-        return result
-    except Exception as e:
-        logging.error(f"Error processing text file: {str(e)}")
-        return f"텍스트 파일 처리 오류: {str(e)}"
-
-def process_csv_file(file):
-    try:
-        content = file.read()
-        file.seek(0)
-
-        df = pd.read_csv(io.BytesIO(content))
-        result = f"## CSV 파일: {file.name}\n\n"
-        result += f"- 행: {len(df)}\n"
-        result += f"- 열: {len(df.columns)}\n"
-        result += f"- 열 이름: {', '.join(df.columns.tolist())}\n\n"
-
-        result += "### 데이터 미리보기\n\n"
-        preview_df = df.head(10)
-        try:
-            markdown_table = preview_df.to_markdown(index=False)
-            if markdown_table:
-                result += markdown_table + "\n\n"
-            else:
-                result += "CSV 데이터를 표시할 수 없습니다.\n\n"
-        except Exception as e:
-            logging.error(f"Markdown table conversion error: {e}")
-            result += "텍스트로 데이터 표시:\n\n" + str(preview_df) + "\n\n"
-
-        num_cols = df.select_dtypes(include=['number']).columns
-        if len(num_cols) > 0:
-            result += "### 기본 통계 정보\n\n"
-            try:
-                stats_df = df[num_cols].describe().round(2)
-                stats_markdown = stats_df.to_markdown()
-                if stats_markdown:
-                    result += stats_markdown + "\n\n"
-                else:
-                    result += "통계 정보를 표시할 수 없습니다.\n\n"
-            except Exception as e:
-                logging.error(f"Statistical info conversion error: {e}")
-                result += "통계 정보를 생성할 수 없습니다.\n\n"
-
-        return result
-    except Exception as e:
-        logging.error(f"CSV file processing error: {str(e)}")
-        return f"CSV 파일 처리 오류: {str(e)}"
-
-def process_pdf_file(file):
-    try:
-        file_bytes = file.read()
-        file.seek(0)
-
-        pdf_file = io.BytesIO(file_bytes)
-        reader = PyPDF2.PdfReader(pdf_file, strict=False)
-
-        result = f"## PDF 파일: {file.name}\n\n- 총 페이지: {len(reader.pages)}\n\n"
-
-        max_pages = min(5, len(reader.pages))
-        all_text = ""
-
-        for i in range(max_pages):
-            try:
-                page = reader.pages[i]
-                page_text = page.extract_text()
-                current_page_text = f"### 페이지 {i+1}\n\n"
-                if page_text and len(page_text.strip()) > 0:
-                    if len(page_text) > 1500:
-                        current_page_text += page_text[:1500] + "...(축약됨)...\n\n"
-                    else:
-                        current_page_text += page_text + "\n\n"
-                else:
-                    current_page_text += "(텍스트를 추출할 수 없음)\n\n"
-
-                all_text += current_page_text
-
-                if len(all_text) > 8000:
-                    all_text += "...(나머지 페이지 축약됨)...\n\n"
-                    break
-
-            except Exception as page_err:
-                logging.error(f"Error processing PDF page {i+1}: {str(page_err)}")
-                all_text += f"### 페이지 {i+1}\n\n(내용 추출 오류: {str(page_err)})\n\n"
-
-        if len(reader.pages) > max_pages:
-            all_text += f"\n참고: 처음 {max_pages} 페이지만 표시됩니다.\n\n"
-
-        result += "### PDF 내용\n\n" + all_text
-        return result
-
-    except Exception as e:
-        logging.error(f"PDF file processing error: {str(e)}")
-        return f"## PDF 파일: {file.name}\n\n오류: {str(e)}\n\n처리할 수 없습니다."
-
-def process_uploaded_files(files):
-    if not files:
-        return None
-
-    result = "# 업로드된 파일 내용\n\n사용자가 제공한 파일의 내용입니다.\n\n"
-    for file in files:
-        try:
-            ext = file.name.split('.')[-1].lower()
-            if ext == 'txt':
-                result += process_text_file(file) + "\n\n---\n\n"
-            elif ext == 'csv':
-                result += process_csv_file(file) + "\n\n---\n\n"
-            elif ext == 'pdf':
-                result += process_pdf_file(file) + "\n\n---\n\n"
-            else:
-                result += f"### 지원되지 않는 파일: {file.name}\n\n---\n\n"
-        except Exception as e:
-            logging.error(f"File processing error {file.name}: {e}")
-            result += f"### 파일 처리 오류: {file.name}\n\n오류: {e}\n\n---\n\n"
-
-    return result
-
-# ──────────────────────────────── Image & Utility ─────────────────────────
-
-def generate_image(prompt, w=768, h=768, g=3.5, steps=30, seed=3):
-    if not prompt:
-        return None, "Insufficient prompt"
-    try:
-        res = Client(IMAGE_API_URL).predict(
-            prompt=prompt, width=w, height=h, guidance=g,
-            inference_steps=steps, seed=seed,
-            do_img2img=False, init_image=None,
-            image2image_strength=0.8, resize_img=True,
-            api_name="/generate_image"
-        )
-        return res[0], f"Seed: {res[1]}"
-    except Exception as e:
-        logging.error(e)
-        return None, str(e)
-
-def extract_image_prompt(response_text: str, topic: str):
-    client = get_openai_client()
-    try:
-        response = client.chat.completions.create(
-            model="gpt-4.1-mini",
-            messages=[
-                {"role": "system", "content": "농업 및 농산물에 관한 이미지 프롬프트를 생성합니다. 한 줄의 영어로 된 프롬프트만 반환하세요, 다른 텍스트는 포함하지 마세요."},
-                {"role": "user", "content": f"주제: {topic}\n\n---\n{response_text}\n\n---"}
-            ],
-            temperature=1,
-            max_tokens=80,
-            top_p=1
-        )
-        return response.choices[0].message.content.strip()
-    except Exception as e:
-        logging.error(f"OpenAI image prompt generation error: {e}")
-        return f"A professional photograph of agricultural produce and farm fields, data visualization of crop prices and trends, high quality"
-
-def md_to_html(md: str, title="농산물 수요 예측 분석 결과"):
-    return f"<!DOCTYPE html><html><head><title>{title}</title><meta charset='utf-8'></head><body>{markdown.markdown(md)}</body></html>"
-
-def keywords(text: str, top=5):
-    cleaned = re.sub(r"[^가-힣a-zA-Z0-9\s]", "", text)
-    return " ".join(cleaned.split()[:top])
-
-# ──────────────────────────────── Streamlit UI ────────────────────────────
-def agricultural_price_forecast_app():
-    st.title("Agriculture GPT")
-    st.markdown("UN 글로벌 식량 및 농업 통계 데이터셋 분석 기반의 농산물 시장 예측")
-
-    if "ai_model" not in st.session_state:
-        st.session_state.ai_model = "gpt-4.1-mini"
-    if "messages" not in st.session_state:
-        st.session_state.messages = []
-    if "auto_save" not in st.session_state:
-        st.session_state.auto_save = True
-    if "generate_image" not in st.session_state:
-        st.session_state.generate_image = False
-    if "web_search_enabled" not in st.session_state:
-        st.session_state.web_search_enabled = True
-    if "analysis_mode" not in st.session_state:
-        st.session_state.analysis_mode = "price_forecast"
-    if "response_style" not in st.session_state:
-        st.session_state.response_style = "professional"
-    if "use_soybean_dataset" not in st.session_state:
-        st.session_state.use_soybean_dataset = False
-
-    sb = st.sidebar
-    sb.title("분석 설정")
-    
-    # Kaggle dataset info display
-    if sb.checkbox("데이터셋 정보 표시", value=False):
-        st.info("UN 글로벌 식량 및 농업 통계 데이터셋을 불러오는 중...")
-        dataset_info = load_agriculture_dataset()
-        if dataset_info:
-            st.success(f"데이터셋 로드 완료: {len(dataset_info['files'])}개 파일")
-            
-            with st.expander("데이터셋 미리보기", expanded=False):
-                for file_info in dataset_info['files'][:5]:
-                    st.write(f"**{file_info['name']}** ({file_info['size_mb']} MB)")
-        else:
-            st.error("데이터셋을 불러오는데 실패했습니다. Kaggle API 설정을 확인하세요.")
-    
-    sb.subheader("분석 구성")
-    sb.selectbox(
-        "분석 모드", 
-        options=list(ANALYSIS_MODES.keys()), 
-        format_func=lambda x: ANALYSIS_MODES[x],
-        key="analysis_mode"
-    )
-    
-    sb.selectbox(
-        "응답 스타일",
-        options=list(RESPONSE_STYLES.keys()),
-        format_func=lambda x: RESPONSE_STYLES[x],
-        key="response_style"
-    )
-    
-    # Dataset selection
-    sb.subheader("데이터셋 선택")
-    sb.checkbox(
-        "고급 대�� 농업 데이터셋 사용",
-        key="use_soybean_dataset",
-        help="대두(콩) 관련 질문에 더 정확한 정보를 제공합니다."
-    )
-    
-    # Always enabled datasets info
-    sb.info("기본 활성화된 데이터셋:\n- UN 글로벌 식량 및 농업 통계\n- 토양 및 환경 변수 기반 작물 추천\n- 기후 변화가 농업에 미치는 영향")
-    
-    # Example queries
-    sb.subheader("예시 질문")
-    c1, c2, c3 = sb.columns(3)
-    if c1.button("쌀 가격 전망", key="ex1"):
-        process_example(EXAMPLE_QUERIES["example1"])
-    if c2.button("기후 영향", key="ex2"):
-        process_example(EXAMPLE_QUERIES["example2"])
-    if c3.button("증평군 작물", key="ex3"):
-        process_example(EXAMPLE_QUERIES["example3"])
-    
-    sb.subheader("기타 설정")
-    sb.toggle("자동 저장", key="auto_save")
-    sb.toggle("이미지 자동 생성", key="generate_image")
-    
-    web_search_enabled = sb.toggle("웹 검색 사용", value=st.session_state.web_search_enabled)
-    st.session_state.web_search_enabled = web_search_enabled
-    
-    if web_search_enabled:
-        st.sidebar.info("✅ 웹 검색 결과가 응답에 통합됩니다.")
-
-    # Download the latest response
-    latest_response = next(
-        (m["content"] for m in reversed(st.session_state.messages) 
-         if m["role"] == "assistant" and m["content"].strip()), 
-        None
-    )
-    if latest_response:
-        title_match = re.search(r"# (.*?)(\n|$)", latest_response)
-        if title_match:
-            title = title_match.group(1).strip()
-        else:
-            first_line = latest_response.split('\n', 1)[0].strip()
-            title = first_line[:40] + "..." if len(first_line) > 40 else first_line
-        
-        sb.subheader("최신 응답 다운로드")
-        d1, d2 = sb.columns(2)
-        d1.download_button("마크다운으로 다운로드", latest_response, 
-                           file_name=f"{title}.md", mime="text/markdown")
-        d2.download_button("HTML로 다운로드", md_to_html(latest_response, title),
-                           file_name=f"{title}.html", mime="text/html")
-
-    # JSON conversation record upload
-    up = sb.file_uploader("대화 기록 불러오기 (.json)", type=["json"], key="json_uploader")
-    if up:
-        try:
-            st.session_state.messages = json.load(up)
-            sb.success("대화 기록을 성공적으로 불러왔습니다")
-        except Exception as e:
-            sb.error(f"불러오기 실패: {e}")
-
-    # JSON conversation record download
-    if sb.button("대화 기록을 JSON으로 다운로드"):
-        sb.download_button(
-            "저장",
-            data=json.dumps(st.session_state.messages, ensure_ascii=False, indent=2),
-            file_name="conversation_history.json",
-            mime="application/json"
-        )
-
-    # File Upload
-    st.subheader("파일 업로드")
-    uploaded_files = st.file_uploader(
-        "참고 자료로 사용할 파일 업로드 (txt, csv, pdf)",
-        type=["txt", "csv", "pdf"],
-        accept_multiple_files=True,
-        key="file_uploader"
-    )
-    
-    if uploaded_files:
-        file_count = len(uploaded_files)
-        st.success(f"{file_count}개 파일이 업로드되었습니다. 질의에 대한 소스로 사용됩니다.")
-        
-        with st.expander("업로드된 파일 미리보기", expanded=False):
-            for idx, file in enumerate(uploaded_files):
-                st.write(f"**파일명:** {file.name}")
-                ext = file.name.split('.')[-1].lower()
-                
-                if ext == 'txt':
-                    preview = file.read(1000).decode('utf-8', errors='ignore')
-                    file.seek(0)
-                    st.text_area(
-                        f"{file.name} 미리보기",
-                        preview + ("..." if len(preview) >= 1000 else ""),
-                        height=150
-                    )
-                elif ext == 'csv':
-                    try:
-                        df = pd.read_csv(file)
-                        file.seek(0)
-                        st.write("CSV 미리보기 (최대 5행)")
-                        st.dataframe(df.head(5))
-                    except Exception as e:
-                        st.error(f"CSV 미리보기 실패: {e}")
-                elif ext == 'pdf':
-                    try:
-                        file_bytes = file.read()
-                        file.seek(0)
-                        
-                        pdf_file = io.BytesIO(file_bytes)
-                        reader = PyPDF2.PdfReader(pdf_file, strict=False)
-                        
-                        pc = len(reader.pages)
-                        st.write(f"PDF 파일: {pc}페이지")
-                        
-                        if pc > 0:
-                            try:
-                                page_text = reader.pages[0].extract_text()
-                                preview = page_text[:500] if page_text else "(텍스트 추출 불가)"
-                                st.text_area("첫 페이지 미리보기", preview + "...", height=150)
-                            except:
-                                st.warning("첫 페이지 텍스트 추출 실패")
-                    except Exception as e:
-                        st.error(f"PDF 미리보기 실패: {e}")
-
-                if idx < file_count - 1:
-                    st.divider()
-
-    # Display existing messages
-    for m in st.session_state.messages:
-        with st.chat_message(m["role"]):
-            st.markdown(m["content"], unsafe_allow_html=True)
-            
-            # Videos
-            if "videos" in m and m["videos"]:
-                st.subheader("관련 비디오")
-                for video in m["videos"]:
-                    video_title = video.get('title', '관련 비디오')
-                    video_url   = video.get('url', '')
-                    thumbnail   = video.get('thumbnail', '')
-                    
-                    if thumbnail:
-                        col1, col2 = st.columns([1, 3])
-                        with col1:
-                            st.write("🎬")
-                        with col2:
-                            st.markdown(f"**[{video_title}]({video_url})**")
-                            st.write(f"출처: {video.get('source', '알 수 없음')}")
-                    else:
-                        st.markdown(f"🎬 **[{video_title}]({video_url})**")
-                        st.write(f"출처: {video.get('source', '알 수 없음')}")
-
-    # User input
-    query = st.chat_input("농산물 가격, 수요 또는 시장 동향 관련 질문을 입력하세요.")
-    if query:
-        process_input(query, uploaded_files)
-
-    sb.markdown("---")
-    sb.markdown("Created by Vidraft | [Community](https://discord.gg/openfreeai)")
-
-def process_example(topic):
-    process_input(topic, [])
-
-def process_input(query: str, uploaded_files):
-    if not any(m["role"] == "user" and m["content"] == query for m in st.session_state.messages):
-        st.session_state.messages.append({"role": "user", "content": query})
-
-    with st.chat_message("user"):
-        st.markdown(query)
-    
-    with st.chat_message("assistant"):
-        placeholder = st.empty()
-        message_placeholder = st.empty()
-        full_response = ""
-
-        use_web_search = st.session_state.web_search_enabled
-        has_uploaded_files = bool(uploaded_files) and len(uploaded_files) > 0
-        
-        try:
-            status = st.status("질문에 답변 준비 중...")
-            status.update(label="클라이언트 초기화 중...")
-            
-            client = get_openai_client()
-            
-            search_content = None
-            video_results = []
-            news_results = []
-            
-            # 농업 데이터셋 분석 결과 가져오기
-            status.update(label="농업 데이터셋 분석 중...")
-            with st.spinner("데이터셋 분석 중..."):
-                dataset_analysis = analyze_dataset_for_query(query)
-                
-                # 항상 포함되는 추가 데이터셋 분석
-                crop_recommendation_analysis = analyze_crop_recommendation_dataset(query)
-                climate_impact_analysis = analyze_climate_impact_dataset(query)
-
-                # 조건부 데이터셋 분석
-                soybean_analysis = None
-                if st.session_state.use_soybean_dataset:
-                    status.update(label="대두 농업 데이터셋 분석 중...")
-                    with st.spinner("대두 데이터셋 분석 중..."):
-                        soybean_analysis = analyze_soybean_dataset(query)
-
-            
-            if use_web_search:
-                # 웹 검색 과정은 노출하지 않고 조용히 진행
-                with st.spinner("정보 수집 중..."):
-                    search_content = do_web_search(keywords(query, top=5))
-                    video_results = brave_video_search(query, 2)
-                    news_results = brave_news_search(query, 3)
-            
-            file_content = None
-            if has_uploaded_files:
-                status.update(label="업로드된 파일 처리 중...")
-                with st.spinner("파일 분석 중..."):
-                    file_content = process_uploaded_files(uploaded_files)
-            
-            valid_videos = []
-            for vid in video_results:
-                url = vid.get('video_url')
-                if url and url.startswith('http'):
-                    valid_videos.append({
-                        'url': url,
-                        'title': vid.get('title', '비디오'),
-                        'thumbnail': vid.get('thumbnail_url', ''),
-                        'source': vid.get('source', '비디오 출처')
-                    })
-            
-            status.update(label="종합 분석 준비 중...")
-            sys_prompt = get_system_prompt(
-                mode=st.session_state.analysis_mode,
-                style=st.session_state.response_style,
-                include_search_results=use_web_search,
-                include_uploaded_files=has_uploaded_files
-            )
-
-            api_messages = [
-                {"role": "system", "content": sys_prompt}
-            ]
-            
-            user_content = query
-            # 항상 기본 데이터셋 분석 결과 포함
-            user_content += "\n\n" + dataset_analysis
-            user_content += "\n\n" + crop_recommendation_analysis
-            user_content += "\n\n" + climate_impact_analysis
-            
-            # 조건부 데이터셋 결과 포함
-            if soybean_analysis:
-                user_content += "\n\n" + soybean_analysis
-            
-            if search_content:
-                user_content += "\n\n" + search_content
-            if file_content:
-                user_content += "\n\n" + file_content
-            
-            if valid_videos:
-                user_content += "\n\n# 관련 동영상\n"
-                for i, vid in enumerate(valid_videos):
-                    user_content += f"\n{i+1}. **{vid['title']}** - [{vid['source']}]({vid['url']})\n"
-            
-            api_messages.append({"role": "user", "content": user_content})
-            
-            try:
-                stream = client.chat.completions.create(
-                    model="gpt-4.1-mini",
-                    messages=api_messages,
-                    temperature=1,
-                    max_tokens=MAX_TOKENS,
-                    top_p=1,
-                    stream=True
-                )
-                
-                for chunk in stream:
-                    if chunk.choices and len(chunk.choices) > 0 and chunk.choices[0].delta.content is not None:
-                        content_delta = chunk.choices[0].delta.content
-                        full_response += content_delta
-                        message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
-                
-                message_placeholder.markdown(full_response, unsafe_allow_html=True)
-                
-                if valid_videos:
-                    st.subheader("관련 비디오")
-                    for video in valid_videos:
-                        video_title = video.get('title', '관련 비디오')
-                        video_url   = video.get('url', '')
-                        
-                        st.markdown(f"🎬 **[{video_title}]({video_url})**")
-                        st.write(f"출처: {video.get('source', '알 수 없음')}")
-
-                status.update(label="응답 완료!", state="complete")
-                
-                st.session_state.messages.append({
-                    "role": "assistant", 
-                    "content": full_response,
-                    "videos": valid_videos
-                })
-                
-            except Exception as api_error:
-                error_message = str(api_error)
-                logging.error(f"API 오류: {error_message}")
-                status.update(label=f"오류: {error_message}", state="error")
-                raise Exception(f"응답 생성 오류: {error_message}")
-            
-            if st.session_state.generate_image and full_response:
-                with st.spinner("맞춤형 이미지 생성 중..."):
-                    try:
-                        ip = extract_image_prompt(full_response, query)
-                        img, cap = generate_image(ip)
-                        if img:
-                            st.subheader("AI 생성 이미지")
-                            st.image(img, caption=cap, use_container_width=True)
-                    except Exception as img_error:
-                        logging.error(f"이미지 생성 오류: {str(img_error)}")
-                        st.warning("맞춤형 이미지 생성에 실패했습니다.")
-
-            if full_response:
-                st.subheader("이 응답 다운로드")
-                c1, c2 = st.columns(2)
-                c1.download_button(
-                    "마크다운", 
-                    data=full_response, 
-                    file_name=f"{query[:30]}.md",
-                    mime="text/markdown"
-                )
-                c2.download_button(
-                    "HTML",
-                    data=md_to_html(full_response, query[:30]),
-                    file_name=f"{query[:30]}.html",
-                    mime="text/html"
-                )
-
-            if st.session_state.auto_save and st.session_state.messages:
-                try:
-                    fn = f"conversation_history_auto_{datetime.now():%Y%m%d_%H%M%S}.json"
-                    with open(fn, "w", encoding="utf-8") as fp:
-                        json.dump(st.session_state.messages, fp, ensure_ascii=False, indent=2)
-                except Exception as e:
-                    logging.error(f"자동 저장 실패: {e}")
-
-        except Exception as e:
-            error_message = str(e)
-            placeholder.error(f"오��� 발생: {error_message}")
-            logging.error(f"입력 처리 오류: {error_message}")
-            ans = f"요청 처리 중 오류가 발생했습니다: {error_message}"
-            st.session_state.messages.append({"role": "assistant", "content": ans})
-
-# ──────────────────────────────── main ────────────────────────────────────
-def main():
-    st.write("==== 애플리케이션 시작 시간:", datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "=====")
-    agricultural_price_forecast_app()
+        st.error(f"⚠️ Error loading or executing the application: {str(e)}")
+        import traceback
+        st.code(traceback.format_exc())
 
 if __name__ == "__main__":
-    main()  
-    
+    main()