Add better error handling and logging for debugging HF Spaces issues

2_backend_llm/app/data_loader.py

@@ -16,11 +16,34 @@ def load_feedback(csv_path: str | None = None) -> pd.DataFrame:
     path_str = csv_path or settings.csv_path
     # Resolve path relative to project root if it's a relative path
     if Path(path_str).is_absolute():
-        path = path_str
+        path = Path(path_str)
     else:
         # Calculate project root: 2_backend_llm/app/data_loader.py -> root/
         project_root = Path(__file__).resolve().parent.parent.parent
         path = project_root / path_str
+    
+    # Debug: print path information
+    print(f"🔍 Looking for CSV file at: {path}", flush=True)
+    print(f"🔍 Path exists: {path.exists()}", flush=True)
+    print(f"🔍 Current working directory: {Path.cwd()}", flush=True)
+    print(f"🔍 Project root: {project_root}", flush=True)
+    
+    if not path.exists():
+        # Try alternative paths
+        alt_paths = [
+            project_root / "0_preprocessing" / "feedback_transformed_2.csv",
+            Path("0_preprocessing") / "feedback_transformed_2.csv",
+            Path("feedback_transformed_2.csv"),
+        ]
+        for alt_path in alt_paths:
+            if alt_path.exists():
+                print(f"✅ Found CSV at alternative path: {alt_path}", flush=True)
+                path = alt_path
+                break
+        else:
+            raise FileNotFoundError(f"CSV file not found at {path}. Tried: {[str(p) for p in [path] + alt_paths]}")
+    
+    print(f"✅ Loading CSV from: {path}", flush=True)
     df = pd.read_csv(path)
     # Basic normalization of expected columns if present
     expected = ["ID", "ServiceName", "Level", "Text"]

2_backend_llm/app/sql_service.py

@@ -327,14 +327,47 @@ class SQLFeedbackService:
         3. Execute SQL queries
         4. Synthesize answer
         """
+        print(f"🔍 Analyzing query: {query}", flush=True)
+        
         if self.df is None:
-            raise ValueError("No feedback data available. Please ensure feedback_transformed_2.csv exists in 0_preprocessing/ directory.")
+            error_msg = "No feedback data available. Please ensure feedback_transformed_2.csv exists in 0_preprocessing/ directory."
+            print(f"❌ {error_msg}", flush=True)
+            raise ValueError(error_msg)
+        
+        print(f"✅ Data loaded: {len(self.df)} rows", flush=True)
+        
+        # Check API keys
+        if not settings.gemini_api_key and not settings.openai_api_key:
+            error_msg = "❌ No API keys configured! Please set GEMINI_API_KEY or OPENAI_API_KEY in Repository secrets."
+            print(error_msg, flush=True)
+            return AnalysisResult(
+                user_query=query,
+                sql_queries=[],
+                query_results=[],
+                summary=error_msg,
+                visualizations=None
+            )
+        
+        print(f"✅ API keys available: Gemini={bool(settings.gemini_api_key)}, OpenAI={bool(settings.openai_api_key)}", flush=True)
         
         # Step 1: Generate SQL queries (with gibberish validation)
         try:
+            print("🔍 Generating SQL queries...", flush=True)
             sql_queries = self._generate_sql_queries(query)
+            print(f"✅ Generated {len(sql_queries)} SQL queries", flush=True)
+            if len(sql_queries) == 0:
+                error_msg = "לא נוצרו שאילתות SQL. ייתכן שהשאלה לא ברורה או שיש בעיה עם ה-API. נסה לשאול שאלה אחרת או בדוק את ה-API keys."
+                print(f"❌ {error_msg}", flush=True)
+                return AnalysisResult(
+                    user_query=query,
+                    sql_queries=[],
+                    query_results=[],
+                    summary=error_msg,
+                    visualizations=None
+                )
         except ValueError as e:
             # If query is gibberish, return a friendly error message
+            print(f"❌ Query validation error: {e}", flush=True)
             return AnalysisResult(
                 user_query=query,
                 sql_queries=[],
@@ -342,11 +375,27 @@ class SQLFeedbackService:
                 summary=str(e),
                 visualizations=None
             )
+        except Exception as e:
+            error_msg = f"שגיאה ביצירת שאילתות SQL: {str(e)}. בדוק את ה-API keys והחיבור לאינטרנט."
+            print(f"❌ {error_msg}", flush=True)
+            import traceback
+            traceback.print_exc()
+            return AnalysisResult(
+                user_query=query,
+                sql_queries=[],
+                query_results=[],
+                summary=error_msg,
+                visualizations=None
+            )
         
         # Step 2: Execute SQL queries
+        print("🔍 Executing SQL queries...", flush=True)
         query_results = self._execute_sql_queries(sql_queries)
+        successful_results = [r for r in query_results if not r.error and len(r.result) > 0]
+        print(f"✅ Executed {len(query_results)} queries, {len(successful_results)} successful", flush=True)
         
         # Step 3: Synthesize answer
+        print("🔍 Synthesizing answer...", flush=True)
         summary = self._synthesize_answer(query, sql_queries, query_results)
         
         # Step 4: (Optional) Generate visualizations
@@ -425,18 +474,27 @@ class SQLFeedbackService:
         # Try Gemini first
         if settings.gemini_api_key and genai is not None:
             try:
+                print("🔍 Using Gemini API for SQL generation...", flush=True)
                 genai.configure(api_key=settings.gemini_api_key)
                 model = genai.GenerativeModel("gemini-2.0-flash")
                 response = model.generate_content(prompt)
                 text = getattr(response, "text", None)
                 if text:
-                    return self._parse_sql_queries(text)
+                    print(f"✅ Received response from Gemini: {text[:200]}...", flush=True)
+                    queries = self._parse_sql_queries(text)
+                    print(f"✅ Parsed {len(queries)} SQL queries from Gemini response", flush=True)
+                    return queries
+                else:
+                    print("❌ Gemini returned empty response", flush=True)
             except Exception as e:
-                print(f"Gemini error in SQL generation: {e}", flush=True)
+                print(f"❌ Gemini error in SQL generation: {e}", flush=True)
+                import traceback
+                traceback.print_exc()
         
         # Fallback to OpenAI
         if settings.openai_api_key and OpenAI is not None:
             try:
+                print("🔍 Using OpenAI API for SQL generation...", flush=True)
                 client = OpenAI(api_key=settings.openai_api_key)
                 response = client.chat.completions.create(
                     model="gpt-4o-mini",
@@ -445,11 +503,19 @@ class SQLFeedbackService:
                 )
                 text = response.choices[0].message.content
                 if text:
-                    return self._parse_sql_queries(text)
+                    print(f"✅ Received response from OpenAI: {text[:200]}...", flush=True)
+                    queries = self._parse_sql_queries(text)
+                    print(f"✅ Parsed {len(queries)} SQL queries from OpenAI response", flush=True)
+                    return queries
+                else:
+                    print("❌ OpenAI returned empty response", flush=True)
             except Exception as e:
-                print(f"OpenAI error in SQL generation: {e}", flush=True)
+                print(f"❌ OpenAI error in SQL generation: {e}", flush=True)
+                import traceback
+                traceback.print_exc()
         
         # Fallback: return empty list
+        print("❌ No API available or all APIs failed. Returning empty query list.", flush=True)
         return []
     
     def _parse_sql_queries(self, text: str) -> List[str]:
@@ -870,9 +936,17 @@ class SQLFeedbackService:
         # Fallback: generate a detailed answer from query results even if LLM failed
         # This ensures we always return a meaningful answer, not just a status message
         successful_results = [r for r in query_results if not r.error and len(r.result) > 0]
+        failed_results = [r for r in query_results if r.error]
+        
+        if len(sql_queries) == 0:
+            return "לא נוצרו שאילתות SQL. ייתכן שהשאלה לא ברורה או שיש בעיה עם ה-API. נסה לשאול שאלה אחרת או בדוק את ה-API keys ב-Repository secrets."
+        
         if successful_results:
             fallback_text = f"סיכום מפורט של הממצאים:\n\n"
-            fallback_text += f"בוצעו {len(sql_queries)} שאילתות, מתוכן {len(successful_results)} הצליחו והחזירו תוצאות.\n\n"
+            fallback_text += f"בוצעו {len(sql_queries)} שאילתות, מתוכן {len(successful_results)} הצליחו והחזירו תוצאות.\n"
+            if failed_results:
+                fallback_text += f"⚠️ {len(failed_results)} שאילתות נכשלו.\n"
+            fallback_text += "\n"
             
             # Analyze and summarize each result
             for i, qr in enumerate(successful_results, 1):
@@ -896,11 +970,24 @@ class SQLFeedbackService:
                     fallback_text += qr.result.head(5).to_string(index=False)
                     fallback_text += "\n\n"
             
+            if failed_results:
+                fallback_text += "\nשגיאות בשאילתות:\n"
+                for i, qr in enumerate(failed_results, 1):
+                    fallback_text += f"שאילתה {i}: {qr.error}\n"
+                fallback_text += "\n"
+            
             fallback_text += "הערה: תשובה זו נוצרה אוטומטית מהתוצאות. לניתוח מפורט יותר, נסה לשאול שאלה ספציפית יותר."
             return fallback_text
         else:
-            # If no successful results, still provide a helpful message
-            return f"בוצעו {len(sql_queries)} שאילתות, אך לא התקבלו תוצאות מהנתונים.\n\nייתכן שהנתונים לא מכילים מידע התואם לשאלה שנשאלה. נסה לשאול שאלה אחרת או לבדוק את הנתונים הזמינים."
+            # If no successful results, provide detailed error information
+            error_details = ""
+            if failed_results:
+                error_details = "\n\nשגיאות בשאילתות:\n"
+                for i, qr in enumerate(failed_results, 1):
+                    error_details += f"שאילתה {i}: {qr.query}\n"
+                    error_details += f"שגיאה: {qr.error}\n\n"
+            
+            return f"בוצעו {len(sql_queries)} שאילתות, אך לא התקבלו תוצאות מהנתונים.{error_details}\nייתכן שהנתונים לא מכילים מידע התואם לשאלה שנשאלה. נסה לשאול שאלה אחרת או לבדוק את הנתונים הזמינים."
     
     def _generate_visualizations(self, query_results: List[SQLQueryResult]) -> Optional[List[Dict[str, Any]]]:
         """