Complete migration to SQL-based approach

- Removed all RAG-related code and files
- Added quality evaluation system (auto-improvement if score < 80)
- Changed background from green to blue
- Added GitHub and CV links in header
- Added comprehensive documentation (ARCHITECTURE.md)
- Code cleanup and optimization
- Added detailed comments throughout codebase
- Removed unnecessary dependencies
- Updated Dockerfile for SQL-only approach

.query_history.json

@@ -1,38 +1 @@
-[
-  {
-    "query": "איך המשתמשים מרגישים לגבי השירות?",
-    "response": {
-      "summary": "את הנוחות של המשתמש נוחות השירות והאינטואיטיביות של הממשק שירות לקוחות על הפנים מענה זמין יותר בשירות לקוחות שירות קל וידידותי למשתמש "
-    }
-  },
-  {
-    "query": "איך המשתמשים מרגישים לגבי השירות?",
-    "response": {
-      "summary": "את הנוחות של המשתמש נוחות השירות והאינטואיטיביות של הממשק שירות לקוחות על הפנים מענה זמין יותר בשירות לקוחות שירות קל וידידותי למשתמש "
-    }
-  },
-  {
-    "query": "איך המשתמשים מרגישים לגבי השירות?",
-    "response": {
-      "summary": "את הנוחות של המשתמש נוחות השירות והאינטואיטיביות של הממשק שירות לקוחות על הפנים מענה זמין יותר בשירות לקוחות שירות קל וידידותי למשתמש "
-    }
-  },
-  {
-    "query": "בלה",
-    "response": {
-      "summary": "תוגה בלה בלה בלה  זריז  סבבה סבבה"
-    }
-  },
-  {
-    "query": "מה שלומך אחי?",
-    "response": {
-      "summary": "אלופים אתם סיבכתם עם הורה 1 הורה 2 אבתי מאוד\nקליל, פשוט וזריז אתם אלופים  אתם אלופים"
-    }
-  },
-  {
-    "query": "כמה אחוזים של משתמשים אוהב לאכול שוקולד?",
-    "response": {
-      "summary": "0 משובים מכילים את הביטוי 'של משתמשים אוהב לאכול שוקולד'."
-    }
-  }
-]
+[]

ARCHITECTURE.md

@@ -1,229 +1,232 @@
-# 🏗️ ארכיטקטורת המערכת - Feedback Analysis RAG Agent
+# ארכיטקטורת המערכת - Feedback Analysis Agent
 
-מסמך זה מסביר את הארכיטקטורה של המערכת בצורה פשוטה וברורה.
+## סקירה כללית
 
-## 📐 סקירה כללית
+המערכת היא **SQL-based Feedback Analysis Agent** שמאפשרת לשאול שאלות בשפה טבעית על משובי משתמשים ולקבל תשובות מפורטות ומבוססות נתונים.
 
-המערכת היא **RAG Agent** (Retrieval-Augmented Generation) לניתוח משובי משתמשים. היא קוראת משובים מקובץ CSV, יוצרת embeddings, בונה אינדקס חיפוש, ומאפשרת שאילתות חופשיות בעברית.
+## עקרונות הארכיטקטורה
 
-```
-┌─────────────┐
-│   משתמש     │
-│  (דפדפן)    │
-└──────┬──────┘
-       │ HTTP
-       ▼
-┌─────────────────────────────────────┐
-│         FastAPI Server              │
-│         (app/api.py)                │
-│  - /query  - שאילתות חופשיות       │
-│  - /topics - ניתוח נושאים           │
-│  - /sentiment - ניתוח רגשות        │
-│  - /ingest - בניית אינדקס          │
-│  - /health - בדיקת בריאות          │
-└──────┬──────────────────────────────┘
-       │
-       ▼
-┌─────────────────────────────────────┐
-│      RAG Service                    │
-│      (app/rag_service.py)           │
-│  - זיהוי כוונה (ספירה/חיפוש)      │
-│  - חיפוש וקטורי (FAISS)            │
-│  - סינתזה עם LLM (Gemini/OpenAI)   │
-└──────┬──────────────────────────────┘
-       │
-       ├─────────────────┬──────────────────┐
-       ▼                 ▼                  ▼
-┌─────────────┐  ┌──────────────┐  ┌──────────────┐
-│  Embeddings │  │ Vector Store │  │   Analysis   │
-│ (embedding) │  │(vector_store)│  │  (analysis)  │
-└─────────────┘  └──────────────┘  └──────────────┘
-```
+המערכת מבוססת על **4 שלבים עיקריים**:
 
-## 🔧 רכיבי המערכת
+1. **ניתוח שאילתה** - LLM מנתח את שאלת המשתמש
+2. **יצירת שאילתות SQL** - LLM יוצר 1-5 שאילתות SQL רלוונטיות
+3. **ביצוע שאילתות** - שאילתות SQL מבוצעות על הנתונים
+4. **סינתזה ותשובה** - LLM יוצר תשובה מפורטת מהתוצאות, כולל בדיקת איכות אוטומטית
 
-### 1. שכבת נתונים (Data Layer)
+## רכיבי המערכת
 
-**`app/data_loader.py`**
-- קורא את קובץ `Feedback.csv`
-- מחזיר DataFrame עם כל המשובים
+### 1. Backend (Python/FastAPI)
 
-**`app/preprocess.py`**
-- מנקה ומעבד טקסטים לפני יצירת embeddings
-- תמיכה בעברית ואנגלית
+#### `app/api.py`
+- **תפקיד**: FastAPI application - נקודת הכניסה הראשית
+- **Endpoints**:
+  - `POST /query-sql` - שאילתות עיקריות (הגישה היחידה)
+  - `POST /health` - בדיקת תקינות השרת
+  - `GET /history` - היסטוריית שאלות
+  - `POST /history/clear` - ניקוי היסטוריה
+  - `GET /` - ממשק משתמש (frontend)
 
-### 2. שכבת Embeddings
+#### `app/sql_service.py`
+- **תפקיד**: הליבה של המערכת - מטפל בכל תהליך הניתוח
+- **מחלקות**:
+  - `SQLFeedbackService` - השירות הראשי
+  - `SQLQueryResult` - תוצאה של שאילתת SQL אחת
+  - `AnalysisResult` - תוצאה מלאה של ניתוח
 
-**`app/embedding.py`**
-- משתמש ב-Sentence-Transformers (מודל רב-לשוני)
-- ממיר טקסטים לוקטורים מספריים
-- מודל ברירת מחדל: `paraphrase-multilingual-MiniLM-L12-v2`
-
-### 3. שכבת אחסון וקטורי
+**תהליך העבודה**:
+```python
+analyze_query(query) 
+  → _generate_sql_queries()      # שלב 1: יצירת שאילתות SQL
+  → _execute_sql_queries()       # שלב 2: ביצוע שאילתות
+  → _synthesize_answer()         # שלב 3: יצירת תשובה
+    → _evaluate_answer_quality() # בדיקת איכות (אם < 80, שיפור אוטומטי)
+  → _generate_visualizations()   # שלב 4: יצירת גרפים
+```
 
-**`app/vector_store.py`**
-- משתמש ב-FAISS לחיפוש וקטורי מהיר
-- שומר אינדקס ב-`.vector_index/faiss.index`
-- שומר מטא-דאטה ב-`.vector_index/meta.parquet`
+**פונקציות מפתח**:
+- `_generate_sql_queries()` - משתמש ב-LLM ליצירת שאילתות SQL
+- `_execute_sql_queries()` - מריץ שאילתות על SQLite in-memory
+- `_synthesize_answer()` - יוצר תשובה מפורטת מהתוצאות
+- `_evaluate_answer_quality()` - בודק איכות תשובה (0-100)
+- `_generate_visualizations()` - יוצר מפרטי גרפים
+
+#### `app/data_loader.py`
+- **תפקיד**: טעינת נתונים מ-CSV
+- **פונקציה**: `load_feedback()` - טוען ומנקה את קובץ ה-CSV
+
+#### `app/config.py`
+- **תפקיד**: הגדרות מערכת
+- **מכיל**: API keys, נתיבי קבצים, שמות עמודות
+
+### 2. Frontend (HTML/CSS/JavaScript)
+
+#### `app/static/index.html`
+- **תפקיד**: ממשק משתמש
+- **תכונות**:
+  - שדה שאילתה
+  - הצגת תשובות
+  - הצגת שאילתות SQL ותוצאות
+  - גרפים ויזואליים
+  - היסטוריית שאלות
+
+#### `app/static/app.js`
+- **תפקיד**: לוגיקת frontend
+- **פונקציות מפתח**:
+  - `sendQuery()` - שליחת שאילתה לשרת
+  - `showVisualizations()` - הצגת גרפים
+  - `getChartConfig()` - הגדרת גרפים (Chart.js)
+  - `formatSQLResults()` - עיצוב תוצאות SQL
+
+## זרימת נתונים
 
-### 4. שכבת ניתוח
+```
+משתמש → Frontend → API (/query-sql) → SQLFeedbackService
+                                              ↓
+                                    [1] _generate_sql_queries()
+                                              ↓
+                                    [2] _execute_sql_queries()
+                                              ↓
+                                    [3] _synthesize_answer()
+                                              ↓
+                                    [4] _evaluate_answer_quality()
+                                              ↓ (אם < 80)
+                                    [5] שיפור אוטומטי
+                                              ↓
+                                    [6] _generate_visualizations()
+                                              ↓
+                                    ← AnalysisResult
+                                              ↓
+                                    ← JSON Response
+                                              ↓
+                                    Frontend → משתמש
+```
 
-**`app/analysis.py`**
-- מזהה כוונת שאילתה (ספירה/חיפוש/ניתוח)
-- מבצע ספירות מדויקות מהנתונים
-- מזהה מילות מפתח (תודה, תלונות, וכו')
+## LLM Integration
 
-**`app/sentiment.py`**
-- מנתח רגשות במשובים
-- משתמש במודל רב-לשוני
+המערכת תומכת ב-2 LLM providers:
 
-**`app/topics.py`**
-- מקבץ משובים לנושאים באמצעות K-Means
-- מחזיר נושאים עם דוגמאות
+1. **Google Gemini** (מועדף)
+   - מודל: `gemini-2.0-flash`
+   - Fallback אוטומטי ל-OpenAI אם לא זמין
 
-### 5. שכבת RAG
+2. **OpenAI**
+   - מודל: `gpt-4o-mini`
+   - Fallback אם Gemini לא זמין
 
-**`app/rag_service.py`** - הלב של המערכת
+**שימוש ב-LLM ב-3 מקומות**:
+1. יצירת שאילתות SQL (`_generate_sql_queries`)
+2. סינתזה של תשובה (`_synthesize_answer`)
+3. הערכת איכות תשובה (`_evaluate_answer_quality`)
 
-**תהליך העבודה:**
-1. **זיהוי כוונה** - האם זו שאילתת ספירה או שאילתת ניתוח?
-2. **חיפוש וקטורי** - מוצא את המשובים הרלוונטיים ביותר
-3. **סינתזה** - משתמש ב-LLM (Gemini/OpenAI) ליצירת תשובה מקצועית
-4. **ולידציה** - מוודא שהתשובה מבוססת על הנתונים
+## Quality Assurance
 
-**תכונות:**
-- תמיכה בשאילתות ספירה מדויקות
-- תמיכה בשאילתות ניתוח מעמיקות
-- תשובות מפורטות ומחוברות לנתונים
-- הבנת הקונטקסט (דירוגים, שירותים)
+### בדיקת איכות אוטומטית
 
-### 6. שכבת API
+המערכת כוללת **מערכת בדיקת איכות אוטומטית**:
 
-**`app/api.py`**
-- FastAPI server עם 5 endpoints
-- מטפל בבקשות HTTP
-- מחזיר תשובות JSON
-- שומר היסטוריית שאילתות
+1. כל תשובה מקבלת ציון 0-100
+2. קריטריונים:
+   - האם התשובה עונה ישירות על השאלה? (0-30 נקודות)
+   - האם התשובה מבוססת על הנתונים? (0-25 נקודות)
+   - האם התשובה מפורטת ומקיפה? (0-20 נקודות)
+   - האם התשובה ברורה ומובנת? (0-15 נקו��ות)
+   - האם התשובה כוללת תובנות עסקיות? (0-10 נקודות)
 
-**Endpoints:**
-- `POST /query` - שאילתות חופשיות
-- `POST /topics` - ניתוח נושאים
-- `POST /sentiment` - ניתוח רגשות
-- `POST /ingest` - בניית אינדקס
-- `POST /health` - בדיקת בריאות
+3. אם הציון < 80:
+   - המערכת מנסה לשפר את התשובה אוטומטית
+   - התשובה המשופרת נבדקת שוב
+   - אם הציון השתפר, התשובה המשופרת מוחזרת
 
-### 7. שכבת ממשק משתמש
+## Visualizations
 
-**`app/static/index.html` + `app/static/app.js`**
-- ממשק ווב פשוט ויפה
-- תמיכה בעברית (RTL)
-- הצגת תשובות והיסטוריה
+המערכת יוצרת **גרפים אוטומטיים** בהתבסס על תוצאות השאילתות:
 
-## 🔄 זרימת נתונים
+- **Bar Chart** - להשוואות בין קטגוריות
+- **Line Chart** - למגמות לאורך זמן
+- **Scatter Plot** - לקשרים בין משתנים
+- **Histogram** - להתפלגות נתונים
 
-### תהליך בניית האינדקס (Ingestion)
+כל גרף כולל:
+- הסבר על סוג הגרף
+- צבעים מגוונים
+- Tooltips אינטראקטיביים
 
-```
-Feedback.csv
-    │
-    ▼
-data_loader.py → DataFrame
-    │
-    ▼
-preprocess.py → טקסטים נקיים
-    │
-    ▼
-embedding.py → וקטורים (embeddings)
-    │
-    ▼
-vector_store.py → FAISS Index
-    │
-    ▼
-.vector_index/faiss.index + meta.parquet
-```
+## Database Schema
 
-### תהליך שאילתה (Query)
+המערכת עובדת עם טבלת `Feedback`:
 
-```
-שאילתת משתמש
-    │
-    ▼
-api.py (/query endpoint)
-    │
-    ▼
-rag_service.py
-    │
-    ├─→ analysis.py (זיהוי כוונה)
-    │
-    ├─→ embedding.py (המרת שאילתה לוקטור)
-    │
-    ├─→ vector_store.py (חיפוש וקטורי)
-    │
-    └─→ LLM (Gemini/OpenAI) - סינתזה
-    │
-    ▼
-תשובה מקצועית למשתמש
+```sql
+CREATE TABLE feedback (
+    ID INTEGER PRIMARY KEY,
+    ServiceName TEXT,      -- שם השירות
+    Level INTEGER,         -- דירוג 1-5
+    Text TEXT,             -- טקסט המשוב
+    CreationDate TEXT      -- תאריך יצירה (אופציונלי)
+);
 ```
 
-## 📊 מבנה הנתונים
+## Security & Configuration
 
-### קובץ Feedback.csv
-```
-ID, ServiceName, Level, Text, ReferenceNumber, RequestID, ProcessID, CreationDate
-```
+- **API Keys**: נטענים מ-`.env` (git-ignored)
+- **Data**: קובץ CSV נטען מהדיסק
+- **History**: נשמר ב-`.query_history.json` (git-ignored)
 
-**שדות חשובים:**
-- `Text` - הטקסט המלא של המשוב
-- `Level` - הדירוג (1-5, 5 = הטוב ביותר)
-- `ServiceName` - שם השירות
+## Deployment
 
-### אינדקס וקטורי
-- **faiss.index** - אינדקס FAISS (14.5 MB)
-- **meta.parquet** - מטא-דאטה (450 KB)
+המערכת יכולה לרוץ:
+- **Locally**: `python run.py`
+- **Docker**: `docker build && docker run`
+- **Runpod**: באמצעות Dockerfile
 
-## 🔐 הגדרות (Configuration)
+## הרחבות עתידיות
 
-**`app/config.py`**
-- קורא משתני סביבה
-- מגדיר נתיבים לקבצים
-- מגדיר שמות עמודות
+1. **Caching** - שמירת תוצאות שאילתות נפוצות
+2. **Multi-language** - תמיכה בשפות נוספות
+3. **Advanced Analytics** - ניתוחים סטטיסטיים מתקדמים
+4. **Real-time Updates** - עדכונים בזמן אמת
+5. **Export** - ייצוא תוצאות ל-PDF/Excel
 
-**משתני סביבה:**
-- `GEMINI_API_KEY` - מפתח Gemini (מומלץ)
-- `OPENAI_API_KEY` - מפתח OpenAI (גיבוי)
-- `CSV_PATH` - נתיב לקובץ CSV
-- `VECTOR_INDEX_PATH` - נתיב לאינדקס
+## שינויים והתאמות
 
-## 🚀 הרצה
+### שינוי מודל LLM
+ערוך ב-`app/sql_service.py`:
+```python
+model = genai.GenerativeModel("gemini-2.0-flash")  # שנה כאן
+```
 
-**`run.py`**
-- נקודת כניסה למערכת
-- מפעיל שרת FastAPI על פורט 8000
+### שינוי סף איכות
+ערוך ב-`app/sql_service.py`:
+```python
+if score < 80:  # שנה כאן (0-100)
+```
 
-## 📦 תלויות עיקריות
+### הוספת עמודות חדשות
+ערוך ב-`app/sql_service.py` → `_get_schema_info()`:
+```python
+schema_info = f"""
+טבלת Feedback מכילה את השדות הבאים:
+- ID: ...
+- NewColumn: ...  # הוסף כאן
+"""
+```
 
-- **FastAPI** - שרת API
-- **Sentence-Transformers** - יצירת embeddings
-- **FAISS** - חיפוש וקטורי
-- **Pandas** - עיבוד נתונים
-- **Google Generative AI** - Gemini LLM
-- **OpenAI** - GPT (גיבוי)
+### שינוי עיצוב Frontend
+ערוך ב-`app/static/index.html` (CSS) ו-`app/static/app.js` (JavaScript)
 
-## 🔍 נקודות חשובות
+## Troubleshooting
 
-1. **האינדקס נבנה פעם אחת** - אחרי בנייה, החיפוש מהיר מאוד
-2. **המערכת עובדת על CPU** - לא צריך GPU
-3. **תמיכה בעברית מלאה** - מהשאילתה ועד התשובה
-4. **תשובות מבוססות נתונים** - המערכת לא ממציאה עובדות
-5. **ולידציה כפולה** - בדיקה שהתשובות הגיוניות ומבוססות על הנתונים
+### שגיאת "No feedback data available"
+- ודא שקובץ `Feedback.csv` קיים
+- ודא שהעמודות הנדרשות קיימות: ID, ServiceName, Level, Text
 
-## 📝 סיכום
+### שגיאת API Key
+- ודא שקובץ `.env` קיים עם `GEMINI_API_KEY` או `OPENAI_API_KEY`
 
-המערכת היא **RAG Agent** פשוט ויעיל:
-- קורא משובים מ-CSV
-- יוצר embeddings ומבנה אינדקס
-- מאפשר שאילתות חופשיות
-- מחזיר תשובות מקצועיות ומבוססות נתונים
+### תשובות לא איכותיות
+- בדוק את הלוגים - המערכת מדפיסה ציוני איכות
+- נסה לשנות את ה-prompt ב-`_synthesize_answer()`
 
-כל הרכיבים עובדים יחד כדי לספק ניתוח איכותי של משובי משתמשים.
+## קישורים
 
+- GitHub: [לעדכן]
+- קורות חיים: [לעדכן]

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributing and Usage Guide
 
-This project implements a Retrieval-Augmented Generation (RAG) service over citizen feedback.
+This project implements a SQL-based feedback analysis system using LLM-generated queries.
 
 Goals:
 - Make the API easy to run locally and deploy to Runpod or any container platform.

DEPLOYMENT_GUIDE.md

@@ -1,6 +1,6 @@
 # Deployment Guide - Runpod Cloud
 
-After local testing is complete and all validation checks pass, follow this guide to deploy your Feedback Analysis RAG Agent to Runpod.
+After local testing is complete, follow this guide to deploy your Feedback Analysis Agent to Runpod.
 
 ---
 

Dockerfile

@@ -1,27 +1,25 @@
+# Dockerfile for Feedback Analysis Agent
+# SQL-based feedback analysis system using LLM-generated queries
+
 FROM python:3.10-slim
 
 ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1 \
-    HF_HUB_DISABLE_TELEMETRY=1
+    PIP_NO_CACHE_DIR=1
 
 WORKDIR /app
 
+# Copy and install dependencies
 COPY requirements.txt ./
-# Install Torch CPU wheels first to avoid heavy builds
 RUN pip install --upgrade pip && \
-    pip install --no-cache-dir --index-url https://download.pytorch.org/whl/cpu \
-      torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 && \
     pip install --no-cache-dir -r requirements.txt --default-timeout=100
 
+# Copy application code
 COPY . .
 
-# Pre-download commonly used models to avoid long first-request cold starts.
-# These lines increase the image size but significantly reduce latency on first API call.
-RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')"
-RUN python -c "from transformers import pipeline; pipeline('sentiment-analysis', model='nlptown/bert-base-multilingual-uncased-sentiment')"
-
+# Expose port
 EXPOSE 8000
 
+# Run the application
 CMD ["python", "run.py"]
 

LOCAL_SETUP_GUIDE.md

@@ -1,329 +0,0 @@
-# 🚀 מדריך הרצה מקומית - Feedback Analysis RAG Agent
-
-מדריך מפורט להרצת המערכת באופן מקומי על המחשב שלך.
-
-## 📋 דרישות מוקדמות
-
-1. **Python 3.10+** - ודא שיש לך Python מותקן:
-   ```bash
-   python --version  # צריך להציג 3.10 או גבוה יותר
-   ```
-
-2. **pip** - מנהל חבילות Python (מגיע עם Python)
-
-3. **אינטרנט** - להורדת מודלים בפעם הראשונה
-
-## 🔧 התקנה שלב אחר שלב
-
-### שלב 1: שכפול/הורדת הפרויקט
-
-אם עדיין לא עשית זאת:
-```bash
-cd /path/to/Feedback_Analysis_RAG_Agent_runpod
-```
-
-### שלב 2: יצירת סביבה וירטואלית
-
-```bash
-# יצירת סביבה וירטואלית
-python -m venv .venv
-
-# הפעלת הסביבה (Windows)
-.venv\Scripts\activate
-
-# הפעלת הסביבה (macOS/Linux)
-source .venv/bin/activate
-```
-
-**הערה:** אחרי ההפעלה, תראה `(.venv)` בתחילת שורת הפקודה.
-
-### שלב 3: התקנת תלויות
-
-```bash
-pip install --upgrade pip
-pip install -r requirements.txt
-```
-
-**זמן משוער:** 5-10 דקות (תלוי במהירות האינטרנט)
-
-**מה מותקן:**
-- FastAPI - שרת API
-- Sentence-Transformers - מודל embeddings
-- FAISS - חיפוש וקטורי
-- Pandas, NumPy - עיבוד נתונים
-- ועוד...
-
-### שלב 4: הגדרת מפתחות API (אופציונלי אבל מומלץ)
-
-צור קובץ `.env` בתיקיית הפרויקט:
-
-```bash
-# Windows
-notepad .env
-
-# macOS/Linux
-nano .env
-```
-
-הוסף את המפתחות שלך:
-```
-GEMINI_API_KEY=your_gemini_key_here
-OPENAI_API_KEY=sk-your_openai_key_here
-```
-
-**למה זה חשוב?**
-- **Gemini** - משמש ליצירת תשובות איכותיות בעברית
-- **OpenAI** - גיבוי אם Gemini לא זמין
-
-**ללא מפתחות:** המערכת תעבוד אבל התשובות יהיו פחות איכותיות.
-
-### שלב 5: בניית אינדקס וקטורי (חובה!)
-
-המערכת צריכה לבנות אינדקס מהקובץ `Feedback.csv`:
-
-```bash
-# שיטה 1: באמצעות הסקריפט
-python scripts/precompute_index.py
-
-# שיטה 2: דרך ה-API (אחרי הפעלת השרת)
-# ראה שלב 6
-```
-
-**זמן משוער:** 2-5 דקות (תלוי בגודל הקובץ)
-
-**מה קורה כאן?**
-- קריאת `Feedback.csv`
-- יצירת embeddings לכל משוב
-- שמירת אינדקס FAISS ב-`.vector_index/`
-
-**תוצאה:** תיקייה `.vector_index/` עם:
-- `faiss.index` - האינדקס הווקטורי
-- `meta.parquet` - מטא-דאטה
-
-### שלב 6: הפעלת השרת
-
-```bash
-python run.py
-```
-
-**פלט צפוי:**
-```
-INFO:     Started server process [12345]
-INFO:     Waiting for application startup.
-INFO:     Application startup complete.
-INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
-```
-
-**השרת רץ על:** `http://127.0.0.1:8000`
-
-### שלב 7: פתיחת הממשק
-
-פתח דפדפן וגש ל:
-```
-http://127.0.0.1:8000
-```
-
-**או:**
-```
-http://localhost:8000
-```
-
-**מה תראה:**
-- ממשק יפה וצבעוני בעברית
-- שדה לשאילתות
-- היסטוריית שאלות
-
-## 🧪 בדיקות
-
-### בדיקה 1: בדיקת בריאות השרת
-
-```bash
-curl -X POST http://127.0.0.1:8000/health
-```
-
-**תגובה צפויה:**
-```json
-{"status":"ok"}
-```
-
-### בדיקה 2: שאילתה פשוטה
-
-בממשק האינטרנט, נסה:
-```
-כמה משתמשים כתבו תודה?
-```
-
-**תגובה צפויה:** מספר מדויק של משובים המכילים תודה.
-
-### בדיקה 3: שאילתה מורכבת
-
-```
-מה הנושאים המרכזיים במשובים?
-```
-
-**תגובה צפויה:** רשימת נושאים עם הסברים.
-
-### בדיקה 4: API ישירות
-
-```bash
-curl -X POST http://127.0.0.1:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query": "כמה משתמשים מתלוננים על אלמנטים שלא עובדים", "top_k": 5}'
-```
-
-## 📝 דוגמאות שאילתות
-
-### שאילתות ספירה:
-- "כמה משתמשים כתבו תודה?"
-- "כמה משתמשים מתלוננים על אלמנטים שלא עובדים?"
-- "כמה משובים יש בסך הכל?"
-
-### שאילתות ניתוח:
-- "מה הנושאים המרכזיים במשובים?"
-- "תסווג את התלונות ל-5 סוגים"
-- "אילו שירותים מקבלים את הציונים הנמוכים ביותר?"
-
-### שאילתות חיפוש:
-- "מה המשתמשים אומרים על הטופס?"
-- "מה הבעיות הנפוצות ביותר?"
-
-## 🐛 פתרון בעיות
-
-### בעיה: "Vector index not found"
-
-**פתרון:**
-```bash
-python scripts/precompute_index.py
-```
-
-או דרך ה-API:
-```bash
-curl -X POST http://127.0.0.1:8000/ingest
-```
-
-### בעיה: "ModuleNotFoundError"
-
-**פתרון:**
-```bash
-# ודא שהסביבה הוירטואלית פעילה
-source .venv/bin/activate  # macOS/Linux
-# או
-.venv\Scripts\activate  # Windows
-
-# התקן מחדש
-pip install -r requirements.txt
-```
-
-### בעיה: השרת לא עולה
-
-**בדוק:**
-1. האם פורט 8000 תפוס?
-   ```bash
-   # macOS/Linux
-   lsof -i :8000
-   
-   # Windows
-   netstat -ano | findstr :8000
-   ```
-
-2. האם Python מותקן?
-   ```bash
-   python --version
-   ```
-
-### בעיה: תשובות כלליות מדי
-
-**פתרון:**
-1. ודא שיש מפתח GEMINI_API_KEY ב-`.env`
-2. ודא שהאינדקס נבנה מהנתונים העדכניים
-3. נסה שאילתות ספציפיות יותר
-
-### בעיה: הפרונט לא מציג תשובות
-
-**פתרון:**
-1. פתח את קונסול הדפדפן (F12)
-2. בדוק אם יש שגיאות JavaScript
-3. ודא שהשרת רץ על פורט 8000
-4. נסה לרענן את הדף (Ctrl+R / Cmd+R)
-
-## 📂 מבנה הפרויקט
-
-```
-Feedback_Analysis_RAG_Agent_runpod/
-├── app/                    # קוד האפליקציה
-│   ├── api.py             # נקודות קצה API
-│   ├── rag_service.py     # לוגיקת RAG
-│   ├── analysis.py        # ניתוח שאילתות
-│   ├── static/            # קבצי פרונט
-│   │   ├── index.html
-│   │   └── app.js
-│   └── ...
-├── scripts/               # סקריפטים שימושיים
-│   └── precompute_index.py
-├── .vector_index/         # אינדקס וקטורי (נוצר אוטומטית)
-├── Feedback.csv           # נתוני המשובים
-├── requirements.txt       # תלויות Python
-├── run.py                # נקודת כניסה
-└── README.md             # תיעוד ראשי
-```
-
-## 🔄 עדכון הנתונים
-
-אם עדכנת את `Feedback.csv`:
-
-```bash
-# מחק את האינדקס הישן
-rm -rf .vector_index/  # macOS/Linux
-# או
-rmdir /s .vector_index  # Windows
-
-# בנה מחדש
-python scripts/precompute_index.py
-
-# הפעל מחדש את השרת
-python run.py
-```
-
-## 🎯 טיפים לשימוש
-
-1. **שאילתות ספציפיות** - תקבל תשובות טובות יותר
-2. **השתמש בדוגמאות** - סמן "הצג דוגמאות" לראות את המקורות
-3. **בדוק את ההיסטוריה** - כל השאלות נשמרות
-4. **נסה שאילתות שונות** - המערכת תומכת בשאילתות מגוונות
-
-## 📚 משאבים נוספים
-
-- **API Documentation:** http://127.0.0.1:8000/docs
-- **README.md** - תיעוד כללי
-- **QUICK_START.md** - התחלה מהירה
-
-## ❓ שאלות נפוצות
-
-**Q: כמה זמן לוקח להריץ בפעם הראשונה?**
-A: 10-15 דקות (הורדת מודלים + בניית אינדקס)
-
-**Q: האם צריך GPU?**
-A: לא, המערכת עובדת על CPU
-
-**Q: כמה זיכרון RAM צריך?**
-A: מינימום 4GB, מומלץ 8GB+
-
-**Q: האם זה עובד ב-Windows?**
-A: כן, עובד על Windows, macOS, ו-Linux
-
-**Q: איך אני עוצר את השרת?**
-A: לחץ Ctrl+C בטרמינל
-
-## 🎉 סיכום
-
-אם הגעת עד כאן, המערכת אמורה לעבוד!
-
-**צעדים מהירים:**
-1. `python -m venv .venv && source .venv/bin/activate`
-2. `pip install -r requirements.txt`
-3. `python scripts/precompute_index.py`
-4. `python run.py`
-5. פתח http://127.0.0.1:8000
-
-**בהצלחה! 🚀**
-

MIGRATION_TO_MAIN.md

@@ -0,0 +1,68 @@
+# הוראות להפיכת sqlApproach ל-main
+
+## שלבים
+
+### 1. שמירת השינויים הנוכחיים
+
+```bash
+# ודא שאתה ב-branch sqlApproach
+git branch --show-current  # צריך להציג: sqlApproach
+
+# בדוק את השינויים
+git status
+
+# הוסף את כל השינויים
+git add .
+
+# צור commit
+git commit -m "Complete migration to SQL-based approach
+
+- Removed all RAG-related code and files
+- Added quality evaluation system
+- Improved UI with blue theme
+- Added comprehensive documentation
+- Code cleanup and optimization"
+```
+
+### 2. מעבר ל-main
+
+```bash
+# עבור ל-main
+git checkout main
+
+# מיזוג את sqlApproach ל-main
+git merge sqlApproach
+
+# או אם אתה רוצה להחליף את main לחלוטין:
+# git reset --hard sqlApproach
+```
+
+### 3. עדכון remote (אם יש)
+
+```bash
+# דחוף את השינויים
+git push origin main
+
+# מחק את ה-branch הישן (אופציונלי)
+git branch -d sqlApproach
+git push origin --delete sqlApproach
+```
+
+## הערות
+
+- **גיבוי**: לפני המיזוג, ודא שיש לך גיבוי של main הישן (אם יש)
+- **בדיקה**: אחרי המיזוג, בדוק שהכל עובד:
+  ```bash
+  python run.py
+  # פתח http://127.0.0.1:8000 ובדוק שהכל עובד
+  ```
+
+## מה השתנה
+
+- ✅ כל הקוד הקשור ל-RAG נמחק
+- ✅ המערכת עכשיו מבוססת SQL בלבד
+- ✅ נוספה מערכת בדיקת איכות אוטומטית
+- ✅ UI עודכן עם רקע כחול
+- ✅ נוספו לינקים ל-GitHub וקורות חיים
+- ✅ כל הקוד מתועד ומתועד היטב
+

PROJECT_COMPLETE.md

@@ -1,484 +0,0 @@
-# ✅ PROJECT COMPLETION SUMMARY
-
-**Date:** November 12, 2025  
-**Status:** ✨ **100% COMPLETE - PRODUCTION READY** ✨
-
----
-
-## 🎯 Mission Statement
-
-Build a **Feedback Analysis RAG Agent** that:
-1. ✅ Answers diverse question types (counting, searching, analysis)
-2. ✅ Detects user intent automatically
-3. ✅ Supports Hebrew queries natively
-4. ✅ Works locally for development
-5. ✅ Deploys to Runpod for production
-6. ✅ Includes comprehensive documentation
-
-**Status:** ALL OBJECTIVES ACHIEVED ✅
-
----
-
-## 📦 Deliverables Checklist
-
-### Core System (Complete)
-- [x] FastAPI server with 5 endpoints (all POST)
-- [x] RAG pipeline with intent detection
-- [x] FAISS vector search (14.5 MB index)
-- [x] Multi-language support (Hebrew + English)
-- [x] Query counting logic (1168 thanks verified)
-- [x] Topic extraction (k-means clustering)
-- [x] Sentiment analysis (multilingual)
-- [x] Error handling and validation
- - [x] Free-form RAG synthesizer (analyst-style, broader-context responses)
-
-### Infrastructure (Complete)
-- [x] Virtual environment setup (.venv)
-- [x] Dependencies installed and locked (requirements.txt)
-- [x] Environment configuration (.env.example)
-- [x] Docker containerization (Dockerfile)
-- [x] Server entrypoint (run.py)
-- [x] FAISS index precomputed and optimized
-
-### Testing & Validation (Complete)
-- [x] 7-check validation harness (validate_local.py) - **ALL PASS ✅**
-- [x] Unit tests for all components
-- [x] Integration tests for RAG pipeline
-- [x] End-to-end API endpoint testing
-- [x] Performance benchmarking
-- [x] Error scenario handling
-
-### Documentation (Complete)
-- [x] GETTING_STARTED.txt - Visual quick guide
-- [x] README_TESTING_GUIDE.md - Master navigation guide
-- [x] QUICK_START.md - 5-step setup
-- [x] TESTING_CHECKLIST.md - 15-point validation
-- [x] DEPLOYMENT_GUIDE.md - Runpod deployment
-- [x] SESSION_SUMMARY.md - Architecture overview
-- [x] STATUS_REPORT.md - Project status
-- [x] CONTRIBUTING.md - Development workflow
-
-### Code Quality (Complete)
-- [x] All Python files documented (docstrings)
-- [x] Type hints throughout (Pydantic models)
-- [x] Error handling with try/except
-- [x] Clear variable names and logic
-- [x] No syntax errors (validated)
-- [x] No import errors (validated)
-
----
-
-## 🧪 Validation Results
-
-### Last Validation Run
-```
-Date: November 12, 2025
-Time: ~2 minutes
-Command: python3 scripts/validate_local.py
-Status: ✅ ALL 7 CHECKS PASSED
-```
-
-**Results:**
-```
-[PASS] ✅ Dependencies      - 26/26 packages ready
-[PASS] ✅ CSV file         - 9930 rows verified
-[PASS] ✅ FAISS Index      - 14.5 MB ready
-[PASS] ✅ App imports      - No errors
-[PASS] ✅ Analysis logic   - Counts verified
-[PASS] ✅ RAGService       - Working correctly
-[PASS] ✅ API endpoints    - All responding
-
-Status: PRODUCTION READY ✅
-```
-
----
-
-## 🚀 What's Working
-
-### Query Types (ALL VERIFIED)
-- ✅ Count thank-yous: 1168 (from "כמה משתמשים כתבו תודה")
-- ✅ Count complaints: 352 (from complaint keywords)
-- ✅ Keyword search: Works in Hebrew and English
-- ✅ Semantic search: Embeddings + FAISS working
-- ✅ Free-form RAG: LLM summarization functional
-
-### Multi-Language (VERIFIED)
-- ✅ Hebrew queries → Hebrew responses
-- ✅ English queries → English responses
-- ✅ Auto-language detection working
-- ✅ Text encoding correct (no corruption)
-
-### API Endpoints (ALL TESTED)
-- ✅ `/health` - Status check (working)
-- ✅ `/query` - Main RAG endpoint (working)
-- ✅ `/topics` - Topic extraction (working)
-- ✅ `/sentiment` - Sentiment analysis (working)
-- ✅ `/ingest` - Index rebuilding (working)
-- ✅ `/docs` - Swagger UI (working)
-- ✅ `/redoc` - ReDoc UI (working)
-
-### Performance (VERIFIED)
-- ✅ Health check: <10ms
-- ✅ Query: 1-3 seconds
-- ✅ Sentiment: 5-15 seconds per 100 records
-- ✅ Index build: 30-60 seconds
-- ✅ Scalability: Ready for load
-
-### Quality Metrics (VERIFIED)
-- ✅ Code coverage: 100% (all paths tested)
-- ✅ Error handling: Complete
-- ✅ Documentation: Comprehensive
-- ✅ Performance: Acceptable
-- ✅ Reliability: Stable
-
----
-
-## 📊 Project Statistics
-
-```
-Code
-├─ Python files: 15 (app/ + scripts/)
-├─ Lines of code: ~2000
-├─ Functions/Classes: ~50
-├─ Type hints: 100%
-└─ Docstrings: 100%
-
-Documentation
-├─ Markdown files: 8
-├─ Documentation lines: 2500+
-├─ Code examples: 30+
-└─ Troubleshooting entries: 15+
-
-Testing
-├─ Validation checks: 7/7 PASS
-├─ API endpoints: 5/5 PASS
-├─ Test scenarios: 15/15 PASS
-└─ Coverage: 100%
-
-Data
-├─ Feedback records: 9930
-├─ Indexed records: 9930
-├─ Unique services: 100+
-├─ FAISS index: 14.5 MB
-└─ Metadata: 450 KB
-```
-
----
-
-## 🎓 What You Can Do Now
-
-### Immediate (Today)
-1. **Read** GETTING_STARTED.txt (5 minutes)
-2. **Run** validation: `python3 scripts/validate_local.py`
-3. **Start** server: `python3 run.py`
-4. **Test** endpoint: http://localhost:8000/docs
-
-### Short-term (This Week)
-1. Follow TESTING_CHECKLIST.md (15 tests, 45 min)
-2. Verify all features work
-3. Test different query types
-4. Try in Hebrew and English
-
-### Medium-term (When Ready)
-1. Follow DEPLOYMENT_GUIDE.md
-2. Build Docker image
-3. Deploy to Runpod
-4. Test cloud endpoint
-5. Share with users
-
----
-
-## 📁 File Structure
-
-```
-Feedback_Analysis_RAG_Agent_runpod/
-│
-├── 📄 GETTING_STARTED.txt            👈 START HERE
-├── 📄 README_TESTING_GUIDE.md        (Master guide)
-├── 📄 QUICK_START.md                 (Setup guide)
-├── 📄 TESTING_CHECKLIST.md           (15 tests)
-├── 📄 DEPLOYMENT_GUIDE.md            (Runpod setup)
-├── 📄 SESSION_SUMMARY.md             (Architecture)
-├── 📄 STATUS_REPORT.md               (Project status)
-├── 📄 CONTRIBUTING.md                (Dev workflow)
-│
-├── 🐍 run.py                         (Server start)
-├── 📦 requirements.txt               (Dependencies)
-├── 🔧 Dockerfile                     (Containerization)
-├── 📋 .env.example                   (Config template)
-│
-├── 📂 app/                           (Core system)
-│   ├── api.py                        (FastAPI endpoints)
-│   ├── rag_service.py                (RAG pipeline)
-│   ├── analysis.py                   (Intent detection)
-│   ├── embedding.py                  (Vector encoding)
-│   ├── vector_store.py               (FAISS wrapper)
-│   ├── sentiment.py                  (Sentiment analysis)
-│   ├── topics.py                     (Topic extraction)
-│   ├── preprocess.py                 (Text processing)
-│   ├── data_loader.py                (CSV loading)
-│   ├── config.py                     (Configuration)
-│   └── __init__.py
-│
-├── 📂 scripts/                       (Utilities)
-│   ├── validate_local.py             (7-check validation)
-│   ├── precompute_index.py           (Build index)
-│   └── test_queries.py               (Test queries)
-│
-├── 📂 .vector_index/                 (Precomputed index)
-│   ├── faiss.index                   (14.5 MB)
-│   └── meta.parquet                  (450 KB)
-│
-├── 📂 .venv/                         (Virtual environment)
-│   └── (26 dependencies installed)
-│
-└── 📄 Feedback.csv                   (9930 records)
-```
-
----
-
-## ✅ Validation Proof Points
-
-### Testing Infrastructure
-- ✅ Full validation harness (validate_local.py)
-- ✅ 7 comprehensive checks
-- ✅ All checks passing
-- ✅ Executes in ~2 minutes
-
-### API Functionality
-- ✅ All 5 endpoints respond
-- ✅ JSON serialization working
-- ✅ Error handling in place
-- ✅ Swagger UI accessible
-
-### Data Integrity
-- ✅ CSV validates (9930 rows)
-- ✅ FAISS index valid (14.5 MB)
-- ✅ Metadata complete (450 KB)
-- ✅ No data loss
-
-### Accuracy Verification
-- ✅ Thank-yous: 1168 (matches CSV)
-- ✅ Complaints: 352 (matches CSV)
-- ✅ Total: 9930 (complete)
-- ✅ Language detection: Working
-
-### Performance Verification
-- ✅ Health: <10ms (excellent)
-- ✅ Query: 1-3s (good)
-- ✅ Load handling: Verified
-- ✅ Memory: Efficient
-
----
-
-## 🎯 Quality Assurance Checklist
-
-### Code Quality
-- [x] No syntax errors
-- [x] No import errors
-- [x] Type hints present
-- [x] Docstrings complete
-- [x] Error handling comprehensive
-- [x] Logging implemented
-
-### Testing
-- [x] Unit tests passing
-- [x] Integration tests passing
-- [x] End-to-end tests passing
-- [x] Performance acceptable
-- [x] Error scenarios handled
-- [x] Coverage complete
-
-### Documentation
-- [x] User guides complete
-- [x] Technical docs complete
-- [x] Code comments clear
-- [x] Examples provided
-- [x] Troubleshooting included
-- [x] Navigation clear
-
-### Deployment
-- [x] Local setup works
-- [x] Docker builds
-- [x] Runpod ready
-- [x] Environment config
-- [x] No data conflicts
-- [x] Cloud path preserved
-
----
-
-## 🚀 Launch Readiness
-
-### Green Lights (All Systems Go)
-✅ Code complete and tested  
-✅ All validation checks passing  
-✅ Documentation comprehensive  
-✅ Local setup verified  
-✅ Docker image ready  
-✅ Runpod deployment documented  
-✅ Performance acceptable  
-✅ Security reviewed  
-✅ Scalability planned  
-✅ Backup strategy included  
-
-### No Blockers
-✅ No critical bugs  
-✅ No missing features  
-✅ No data issues  
-✅ No configuration problems  
-✅ No deployment obstacles  
-
-### Status: READY FOR PRODUCTION ✅
-
----
-
-## 🎉 Next Steps for You
-
-### Step 1: Review (5 minutes)
-- Open: GETTING_STARTED.txt
-- Skim: README_TESTING_GUIDE.md
-- Understand: What you have and what you can do
-
-### Step 2: Verify (10 minutes)
-```bash
-source .venv/bin/activate
-python3 scripts/validate_local.py
-python3 run.py
-# Open http://localhost:8000/docs
-```
-
-### Step 3: Test (45 minutes)
-- Follow: TESTING_CHECKLIST.md
-- Run: All 15 test scenarios
-- Verify: Everything works
-
-### Step 4: Deploy (2 hours, optional)
-- Read: DEPLOYMENT_GUIDE.md
-- Build: Docker image
-- Deploy: To Runpod
-- Test: Cloud endpoint
-
----
-
-## 📞 Quick Help
-
-**Where do I start?**
-→ GETTING_STARTED.txt (this directory)
-
-**How do I set up locally?**
-→ QUICK_START.md (5-step guide)
-
-**How do I test everything?**
-→ TESTING_CHECKLIST.md (15 tests)
-
-**How do I deploy to cloud?**
-→ DEPLOYMENT_GUIDE.md (Runpod instructions)
-
-**Why did something fail?**
-→ Check troubleshooting sections in relevant guide
-
-**Can I modify the code?**
-→ Yes, see CONTRIBUTING.md for workflow
-
----
-
-## 📈 Success Metrics
-
-| Metric | Target | Achieved | Status |
-|--------|--------|----------|--------|
-| Code complete | 100% | 100% | ✅ |
-| Tests passing | 100% | 100% | ✅ |
-| Documentation | Complete | 2500+ lines | ✅ |
-| API endpoints | 5/5 working | 5/5 | ✅ |
-| Validation checks | 7/7 pass | 7/7 | ✅ |
-| Performance | <5s queries | 1-3s | ✅ |
-| Accuracy | Verified | 1168/352 | ✅ |
-| Deployment ready | Yes | Yes | ✅ |
-
----
-
-## 🏆 Project Excellence
-
-### What Makes This Project Great
-
-**Completeness**
-- Everything you need is included
-- No missing dependencies
-- No broken functionality
-- Production-ready code
-
-**Documentation**
-- 8 comprehensive guides
-- 2500+ lines of docs
-- Clear navigation
-- Multiple entry points
-
-**Testing**
-- 7-check validation
-- 15-point test suite
-- 100% coverage
-- All scenarios verified
-
-**Quality**
-- Type hints throughout
-- Full docstrings
-- Error handling
-- Clean code
-
-**Deployment**
-- Local setup simple
-- Docker ready
-- Runpod instructions
-- Cloud-ready code
-
----
-
-## 📝 Final Checklist
-
-Before you start testing:
-
-- [x] All code complete
-- [x] All tests passing
-- [x] All documentation written
-- [x] All validation checks passing
-- [x] Environment configured
-- [x] Dependencies installed
-- [x] Index precomputed
-- [x] Docker ready
-- [x] Runpod guide complete
-- [x] No blockers or issues
-
-**Status: READY FOR YOUR TESTING ✅**
-
----
-
-## 🎓 Remember
-
-This is a **production-ready system**. Everything works:
-
-✅ **Locally** - Just run `python3 run.py`  
-✅ **In Docker** - Build and run container  
-✅ **In Cloud** - Runpod deployment ready  
-
-You can start testing immediately!
-
----
-
-## 🌟 Thank You!
-
-Your Feedback Analysis RAG Agent is complete, tested, and ready to use.
-
-**Now:** Start with GETTING_STARTED.txt  
-**Then:** Follow the guide that matches your role  
-**Soon:** You'll have a working, deployed system  
-
-Good luck! 🚀
-
----
-
-**Project Status:** ✨ **100% COMPLETE** ✨  
-**Ready:** YES ✅  
-**Production:** YES ✅  
-**Date:** November 12, 2025  
-**Version:** 1.0  
-

QUICK_START.md

@@ -1,289 +0,0 @@
-# Quick Start - Local Development Guide
-
-This guide shows you how to run the Feedback Analysis RAG Agent locally, test all endpoints, and prepare it for Runpod deployment. Everything works locally first before any cloud deployment.
-
-## Prerequisites
-
-- **Python 3.10+** (verify with `python3 --version`)
-- **Git** (already installed)
-- **Terminal/Command line** access
-- **4GB+ RAM** recommended
-- **~2GB free disk space** for models (first time only)
-
-## Step 1: Install Dependencies
-
-Clone the repo (if not already done):
-```bash
-git clone https://github.com/galbendavids/Feedback_Analysis_RAG_Agent_runpod.git
-cd Feedback_Analysis_RAG_Agent_runpod
-```
-
-Create and activate virtual environment:
-```bash
-python3 -m venv .venv
-source .venv/bin/activate  # On Windows: .venv\Scripts\activate
-```
-
-Install all required packages:
-```bash
-pip install --upgrade pip
-pip install -r requirements.txt
-```
-
-**Note:** First install may take 5-10 minutes as models are large. Subsequent installs are faster.
-
-## Step 2: Prepare Environment Variables (Optional)
-
-Copy the example environment file:
-```bash
-cp .env.example .env
-```
-
-Edit `.env` if you have LLM API keys (optional):
-```bash
-# Edit .env with your editor
-GEMINI_API_KEY=your_key_here  # Optional
-OPENAI_API_KEY=sk-...         # Optional
-```
-
-If you don't have API keys, the system will use extractive summaries (still works fine).
-
-## Step 3: Validate Everything Works
-
-Before starting the server, run the validation harness (this checks all components):
-```bash
-python3 scripts/validate_local.py
-```
-
-Expected output when all is OK:
-```
-============================================================
-VALIDATION SUMMARY
-============================================================
-
-[PASS] Dependencies
-[PASS] CSV file
-[PASS] FAISS Index
-[PASS] App imports
-[PASS] Analysis logic
-[PASS] RAGService
-[PASS] API endpoints
-
-------------------------------------------------------------
-All 7 checks PASSED! Ready for local testing.
-```
-
-If any checks fail, the script will tell you exactly what to fix.
-
-## Step 4: Start the Local Server
-
-Run the API server:
-```bash
-python3 run.py
-```
-
-Expected output:
-```
-INFO:     Uvicorn running on http://0.0.0.0:8000
-Press CTRL+C to quit
-```
-
-The server is now running and ready to accept requests!
-
-## Step 5: Test the API - Three Options
-
-### Option A: Interactive Swagger UI (Easiest)
-
-Open your browser:
-- http://localhost:8000/docs
-
-Click on any endpoint, fill in the JSON, and click "Try it out". You'll see responses in real-time.
-
-### Option B: curl Commands (Terminal)
-
-In a new terminal window (keep server running), try these:
-
-**Health check:**
-```bash
-curl -X POST http://localhost:8000/health
-```
-
-**Count query (עברית):**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"כמה משתמשים כתבו תודה","top_k":5}'
-```
-
-**Complaint query:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"כמה משתמשים מתלוננים על אלמנטים שלא עובדים להם במערכת","top_k":5}'
-```
-
-**Extract topics:**
-```bash
-curl -X POST http://localhost:8000/topics \
-  -H "Content-Type: application/json" \
-  -d '{"num_topics":5}'
-```
-
-**Analyze sentiment:**
-```bash
-curl -X POST http://localhost:8000/sentiment \
-  -H "Content-Type: application/json" \
-  -d '{"limit":100}'
-```
-
-**Build/rebuild index:**
-```bash
-curl -X POST http://localhost:8000/ingest
-```
-
-### Option C: Python Client
-
-Create a file `test_api.py`:
-```python
-import requests
-import json
-
-BASE_URL = "http://localhost:8000"
-
-# Test health
-print("Testing /health...")
-resp = requests.post(f"{BASE_URL}/health")
-print(f"Status: {resp.status_code}")
-print(f"Response: {resp.json()}\n")
-
-# Test query
-print("Testing /query...")
-query_data = {
-    "query": "כמה משתמשים כתבו תודה",
-    "top_k": 5
-}
-resp = requests.post(f"{BASE_URL}/query", json=query_data)
-print(f"Status: {resp.status_code}")
-result = resp.json()
-print(f"Summary: {result.get('summary', 'N/A')}\n")
-
-# Test topics
-print("Testing /topics...")
-topics_data = {"num_topics": 5}
-resp = requests.post(f"{BASE_URL}/topics", json=topics_data)
-print(f"Status: {resp.status_code}")
-result = resp.json()
-print(f"Found {len(result.get('topics', {}))} topics\n")
-
-print("✓ All basic tests completed!")
-```
-
-Run it:
-```bash
-python3 test_api.py
-```
-
-## API Endpoints Reference
-
-All endpoints use **POST** with JSON bodies:
-
-| Endpoint | Body | Purpose |
-|----------|------|---------|
-| `/health` | `{}` | Check server status |
-| `/query` | `{"query":"...", "top_k":5}` | Search/analyze feedback |
-| `/topics` | `{"num_topics":5}` | Extract main topics |
-| `/sentiment` | `{"limit":100}` | Analyze sentiment |
-| `/ingest` | `{}` | Rebuild FAISS index (slow, one-time) |
-
-## Troubleshooting
-
-### Q: Server won't start
-```
-ModuleNotFoundError: No module named 'xxx'
-```
-**Fix:** Activate venv and reinstall:
-```bash
-source .venv/bin/activate
-pip install -r requirements.txt
-```
-
-### Q: First request takes forever
-This is normal! The first request downloads and caches embedding models (~500MB). Subsequent requests are fast.
-**Fix:** Just wait, or use pre-downloaded models (see advanced section).
-
-### Q: Can't find index
-```
-FileNotFoundError: Vector index not found
-```
-**Fix:** Run `/ingest` once:
-```bash
-curl -X POST http://localhost:8000/ingest
-```
-
-### Q: Get JSON parsing error
-Make sure you're sending proper JSON with `-H "Content-Type: application/json"`.
-
-### Q: Responses are in English but I want Hebrew
-The API auto-detects query language and responds in the same language. 
-
-## Project Structure (Reference)
-
-```
-.
-├── app/                      # Main application code
-│   ├── api.py               # FastAPI endpoints
-│   ├── rag_service.py       # RAG logic
-│   ├── analysis.py          # Query intent detection
-│   ├── embedding.py         # Text embeddings
-│   ├── vector_store.py      # FAISS wrapper
-│   ├── sentiment.py         # Sentiment analysis
-│   ├── preprocess.py        # Text preprocessing
-│   ├── data_loader.py       # CSV loading
-│   ├── topics.py            # Topic clustering
-│   └── config.py            # Configuration
-├── scripts/
-│   ├── validate_local.py    # Validation harness (this file)
-│   ├── test_queries.py      # Manual query testing
-│   └── precompute_index.py  # Build index offline
-├── Feedback.csv             # Sample feedback data
-├── Dockerfile               # Container definition
-├── docker-compose.yml       # Docker compose (local dev)
-├── requirements.txt         # Python dependencies
-├── run.py                   # Server entrypoint
-└── README.md                # Full documentation
-```
-
-## Advanced: Pre-compute Index Offline
-
-If you want to avoid waiting for embedding downloads on first request:
-
-```bash
-python3 scripts/precompute_index.py
-```
-
-This creates `.vector_index/faiss.index` and `.vector_index/meta.parquet`. Subsequent server starts will use this cached index.
-
-## Deploy to Runpod
-
-Once local testing is done, follow the **README.md** section "Run on Runpod - Full guide" to:
-1. Tag and push the Docker image
-2. Create a Runpod template
-3. Deploy the endpoint
-4. Test on the cloud
-
-The entire cloud deployment keeps all your code unchanged — it just uses your built Docker image.
-
-## Getting Help
-
-- **API docs (interactive):** http://localhost:8000/docs
-- **Full documentation:** See README.md
-- **Config reference:** See app/config.py
-
-## Next Steps
-
-1. ✅ Validate with: `python3 scripts/validate_local.py`
-2. ✅ Start server: `python3 run.py`
-3. ✅ Test endpoints using Swagger UI or curl
-4. ✅ When happy, deploy to Runpod using README.md instructions
-
-Good luck! 🚀

README.md

@@ -1,263 +1,187 @@
-## Feedback Analysis RAG Agent
-
-An end-to-end system for analyzing citizen feedback with Retrieval-Augmented Generation (RAG). It ingests `Feedback.csv`, creates multilingual embeddings, builds a FAISS vector index, and exposes a FastAPI API for semantic search, topic clustering, and sentiment summaries. Designed to run locally or in containers, and to be deployable to Runpod.
-
-### Features
-- Multilingual ingestion (Hebrew supported) from `Feedback.csv`
-- Preprocessing: optional normalization, language detection
-- Embeddings: Sentence-Transformers (multilingual) + FAISS
-- Retrieval: top-k semantic nearest neighbors with filters
-- Summarization: LLM (OpenAI) if configured; fallback to extractive summary
-  - Supports Gemini (preferred) or OpenAI when API keys are provided
-- Topics: k-means topic clustering over embeddings
-- Sentiment: multilingual transformer pipeline
-- FastAPI endpoints and a simple CLI
-
-### Project layout
-```
-app/
-  api.py
-  config.py
-  data_loader.py
-  embedding.py
-  preprocess.py
-  rag_service.py
-  sentiment.py
-  topics.py
-  vector_store.py
-run.py
-requirements.txt
-Dockerfile
-```
+# Feedback Analysis Agent
 
-### ⚠️ חשוב: Re-encoding נדרש
+מערכת ניתוח משובי משתמשים מבוססת SQL ו-LLM.
 
-אם שינית את מודל ה-embedding (למשל, שיפור מ-MiniLM ל-mpnet), **חובה** להריץ re-encoding של כל הנתונים:
+## סקירה כללית
 
-```bash
-uv run -m scripts.precompute_index
-# או
-python scripts/precompute_index.py
-```
+המערכת מאפשרת לשאול שאלות בשפה טבעית על משובי משתמשים ולקבל תשובות מפורטות ומבוססות נתונים. המערכת משתמשת בגישה מבוססת SQL - LLM יוצר שאילתות SQL, הן מבוצעות על הנתונים, ו-LLM נוסף יוצר תשובה מפורטת מהתוצאות.
+
+## תכונות עיקריות
 
-זה יבנה מחדש את האינדקס הווקטורי עם המודל החדש.
+- ✅ **שאילתות בשפה טבעית** - שאל שאלות בעברית על המשובים
+- ✅ **ניתוח אוטומטי** - המערכת יוצרת שאילתות SQL אוטומטית
+- ✅ **בדיקת איכות אוטומטית** - תשובות נבדקות אוטומטית ומשופרות אם נדרש
+- ✅ **ויזואליזציות** - גרפים אוטומטיים של התוצאות
+- ✅ **ממשק משתמש מודרני** - UI צבעוני ואינטואיטיבי
 
-### Quick start (Local Development)
+## התקנה והרצה
 
-**📖 למדריך מפורט:** ראה [LOCAL_SETUP_GUIDE.md](LOCAL_SETUP_GUIDE.md)
+### דרישות מקדימות
 
-**צעדים מהירים:**
+- Python 3.10+
+- קובץ `Feedback.csv` עם העמודות: ID, ServiceName, Level, Text, CreationDate (אופציונלי)
 
-1. **Python 3.10+** - ודא שיש לך Python מותקן
+### התקנה
 
-2. **יצירת סביבה וירטואלית והתקנה:**
 ```bash
+# יצירת סביבה וירטואלית
 python -m venv .venv
-source .venv/bin/activate  # macOS/Linux
-# או: .venv\Scripts\activate  # Windows
+source .venv/bin/activate  # ב-Windows: .venv\Scripts\activate
 
-pip install --upgrade pip
+# התקנת תלויות
 pip install -r requirements.txt
 ```
 
-3. **הגדרת מפתחות API (מומלץ):**
-צור קובץ `.env`:
-```
+### הגדרת API Keys
+
+צור קובץ `.env` בשורש הפרויקט:
+
+```env
 GEMINI_API_KEY=your_gemini_key_here
-OPENAI_API_KEY=sk-your_openai_key_here
+# או
+OPENAI_API_KEY=your_openai_key_here
 ```
 
-4. **בניית אינדקס וקטורי:**
-```bash
-python scripts/precompute_index.py
-```
+**הערה**: לפחות אחד מה-API keys חייב להיות מוגדר.
+
+### הרצה
 
-5. **הפעלת השרת:**
 ```bash
 python run.py
 ```
 
-6. **פתיחת הממשק:**
-פתח דפדפן וגש ל: **http://127.0.0.1:8000**
-
-**או לבדיקת API:**
-- Swagger UI: http://127.0.0.1:8000/docs
-- Health check: `curl -X POST http://127.0.0.1:8000/health`
+השרת יעלה על `http://127.0.0.1:8000`
 
-**CLI example:**
-```bash
-python -m app.rag_service --query "שיפור טופס" --top_k 5
-```
+פתח את הדפדפן וגש ל-`http://127.0.0.1:8000`
 
-### Configuration
-Environment variables:
-- GEMINI_API_KEY: If set, RAG uses Gemini (preferred) for summaries
-- OPENAI_API_KEY: If set, RAG can use OpenAI as a fallback
-- EMBEDDING_MODEL: Sentence-Transformers model name (default: sentence-transformers/paraphrase-multilingual-mpnet-base-v2)
-- VECTOR_INDEX_PATH: Path to persist FAISS index (default: ./.vector_index/faiss.index)
-- VECTOR_METADATA_PATH: Path to persist FAISS index metadata (default: ./.vector_index/meta.parquet)
-- CSV_PATH: Optional path to your CSV (if not `Feedback.csv` in repo root)
+## ארכיטקטורה
 
-### Notes
-- The first run will download models (embeddings, sentiment); ensure internet access.
-- The system reads from `Feedback.csv` in the repo root. Update `app/data_loader.py` if your schema differs.
+המערכת מבוססת על **4 שלבים**:
 
-### Runpod
-- This repo includes a `Dockerfile`. Build and push the image; configure your Runpod template to run `python run.py` and expose port 8000.
+1. **ניתוח שאילתה** - LLM מנתח את שאלת המשתמש
+2. **יצירת שאילתות SQL** - LLM יוצר 1-5 שאילתות SQL רלוונטיות
+3. **ביצוע שאילתות** - שאילתות SQL מבוצעות על הנתונים (SQLite in-memory)
+4. **סינתזה ותשובה** - LLM יוצר תשובה מפורטת מהתוצאות, כולל בדיקת איכות אוטומטית
 
-### Secrets hygiene
-- Do not commit real secrets. Use environment variables or a local `.env` file.
-- `.env` is gitignored by default via `.gitignore`.
-- Rotate any keys that were ever shared publicly.
+לקריאה מפורטת יותר, ראה [ARCHITECTURE.md](ARCHITECTURE.md)
 
-## Run on Runpod - Full guide
+## מבנה הפרויקט
 
-### 1) Build and push the container
-- From project root:
 ```
-docker build -t YOUR_DOCKERHUB_USER/feedback-rag:latest .
-docker login
-docker push YOUR_DOCKERHUB_USER/feedback-rag:latest
+.
+├── app/
+│   ├── api.py              # FastAPI endpoints
+│   ├── sql_service.py      # ליבת המערכת - SQL-based analysis
+│   ├── config.py           # הגדרות מערכת
+│   ├── data_loader.py      # טעינת נתונים מ-CSV
+│   └── static/
+│       ├── index.html      # ממשק משתמש
+│       └── app.js          # לוגיקת frontend
+├── Feedback.csv            # נתוני המשובים (לא ב-git)
+├── .env                    # API keys (לא ב-git)
+├── requirements.txt        # תלויות Python
+├── run.py                  # נקודת כניסה
+└── ARCHITECTURE.md         # מסמך ארכיטקטורה מפורט
 ```
 
-### 2) Prepare environment variables (no secrets in git)
-- You will set secrets within Runpod, not in code:
-  - Required:
-    - `GEMINI_API_KEY` = your Gemini key
-  - Optional:
-    - `OPENAI_API_KEY` = OpenAI fallback key
-    - `CSV_PATH` = path to your CSV if not the default `Feedback.csv`
-    - `VECTOR_INDEX_PATH` and `VECTOR_METADATA_PATH` if you change mount/paths
-
-### 3) Create a Runpod Template (Serverless HTTP recommended)
-- In Runpod Console → Templates → Create Template
-- Fields:
-  - Container Image: `YOUR_DOCKERHUB_USER/feedback-rag:latest`  (if you want you can use mine: `galbendavids/feedback-rag:latest`)
-  - Container Port: `8000`
-  - Command: `python run.py`
-  - Environment Variables:
-    - `GEMINI_API_KEY=your_key`
-    - (optional) `OPENAI_API_KEY=sk-...`
-    - (optional) `CSV_PATH=/workspace/Feedback.csv`
-    - (optional) `VECTOR_INDEX_PATH=/workspace/.vector_index/faiss.index`
-    - (optional) `VECTOR_METADATA_PATH=/workspace/.vector_index/meta.parquet`
-- Volumes (recommended to persist the FAISS index):
-  - Create a volume, mount it at `/workspace/.vector_index`
-  - Make sure your `VECTOR_*` env vars point to that mount path if changed
-
-### 4) Deploy a Serverless Endpoint
-- Create Endpoint from the template (Serverless)
-- Choose region and CPU (CPU is sufficient)
-- Wait until status is Running and an endpoint URL is provided
-
-### 5) Upload or point to your CSV
-- Option A (bundled): Keep `Feedback.csv` in the image (already in repo root)
-- Option B (mounted): Upload to a mounted volume and set `CSV_PATH` accordingly
-
-### 6) First-time ingestion (build the vector index)
-- Trigger ingestion once to build and persist the FAISS index:
-```
-curl -X POST {YOUR_ENDPOINT_URL}/ingest
-```
-- On first run, models download and embeddings are computed; allow a few minutes
-- The index will be stored under `.vector_index` (persist if using a volume)
+## שימוש
 
-### 7) Test the API
-# Health (POST):
-```
-curl -X POST {YOUR_ENDPOINT_URL}/health
-```
-- Query:
-```
-curl -X POST {YOUR_ENDPOINT_URL}/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"שיפור טופס", "top_k": 5}' \
-  {YOUR_ENDPOINT_URL}/query
-```
-- Topics (POST JSON):
-```
-curl -X POST {YOUR_ENDPOINT_URL}/topics \
-  -H "Content-Type: application/json" \
-  -d '{"num_topics":8}'
-```
-- Sentiment (first N rows, POST JSON):
-```
-curl -X POST {YOUR_ENDPOINT_URL}/sentiment \
+### דרך הממשק
+
+1. פתח `http://127.0.0.1:8000` בדפדפן
+2. הזן שאלה בשדה הטקסט
+3. לחץ על "🔍 שאל"
+4. צפה בתשובה, שאילתות SQL, תוצאות, וגרפים
+
+### דרך API
+
+```bash
+curl -X POST http://127.0.0.1:8000/query-sql \
   -H "Content-Type: application/json" \
-  -d '{"limit":100}'
-```
-- Interactive docs (Swagger UI):
-  - Open `{YOUR_ENDPOINT_URL}/docs` in your browser
-
-### 8) Using Dedicated Pods (alternative)
-- Launch a Dedicated Pod from the template
-- Ensure command `python run.py` and port `8000`
-- Use the Pod’s public endpoint to access `/health`, `/ingest`, `/query`, etc.
-
-### 9) Troubleshooting
-- 404/connection:
-  - Endpoint not Running yet or wrong port; port must be `8000`
-- Slow initial response:
-  - First-time model downloads are expected; subsequent calls are faster
-- No/few results:
-  - Ensure you POSTed `/ingest` first and that your CSV has the `Text` column
-- Index not persisted:
-  - Mount a volume at `/workspace/.vector_index` and set `VECTOR_*` paths
-
-### 10) Optional: Pre-cache models to speed cold starts
-- You can pre-bake model weights in the image by adding to your `Dockerfile`:
-```
-# Optional: pre-download models during build to reduce cold start time
-RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')"
-RUN python -c "from transformers import pipeline; pipeline('sentiment-analysis', model='cardiffnlp/twitter-xlm-roberta-base-sentiment')"
+  -d '{"query": "כמה משתמשים כתבו תודה?", "top_k": 5}'
 ```
-- Rebuild and push the image after adding these lines.
 
-## Offline precompute (embed the DB locally for fast startup)
+## דוגמאות שאלות
 
-If you want the API to start fast on Runpod without running `/ingest` there, precompute the vector index locally:
+- "כמה משתמשים כתבו תודה?"
+- "מה הנושא המרכזי של המשובים שקיבלו ציון נמוך מ-3?"
+- "חלק את המשובים ל-5 נושאים מרכזיים"
+- "כמה משובים התקבלו בחודש האחרון?"
+- "איך המשתמשים מרגישים כלפי השירות?"
 
-1) Create venv and install deps:
-```
-python -m venv .venv && source .venv/bin/activate
-pip install -r requirements.txt
-```
-2) Ensure `Feedback.csv` exists at repo root (or set `CSV_PATH`).
-3) Run the offline precompute script:
+## Quality Assurance
+
+המערכת כוללת **בדיקת איכות אוטומטית**:
+
+- כל תשובה מקבלת ציון 0-100
+- אם הציון < 80, המערכת מנסה לשפר את התשובה אוטומטית
+- הקריטריונים: רלוונטיות, דיוק, מפורטות, בהירות, תובנות עסקיות
+
+## Visualizations
+
+המערכת יוצרת **גרפים אוטומטיים**:
+- Bar Charts - להשוואות
+- Line Charts - למגמות לאורך זמן
+- Scatter Plots - לקשרים בין משתנים
+- Histograms - להתפלגות נתונים
+
+## Deployment
+
+### Docker
+
+```bash
+docker build -t feedback-analysis .
+docker run -p 8000:8000 feedback-analysis
 ```
-python scripts/precompute_index.py
+
+### Runpod
+
+ראה [DEPLOYMENT_GUIDE.md](DEPLOYMENT_GUIDE.md) לפרטים.
+
+## שינויים והתאמות
+
+### שינוי מודל LLM
+
+ערוך ב-`app/sql_service.py`:
+```python
+model = genai.GenerativeModel("gemini-2.0-flash")  # שנה כאן
 ```
-This writes:
-- `.vector_index/faiss.index`
-- `.vector_index/meta.parquet`
 
-4) Option A: Commit the index (makes startup fastest)
-- By default `.vector_index/` is in `.gitignore`. To commit it, you can temporarily remove that entry and run:
+### שינוי סף איכות
+
+ערוך ב-`app/sql_service.py`:
+```python
+if score < 80:  # שנה כאן (0-100)
 ```
-git add .vector_index/faiss.index .vector_index/meta.parquet
-git commit -m "Add precomputed FAISS index"
-git push
+
+### הוספת עמודות חדשות
+
+ערוך ב-`app/sql_service.py` → `_get_schema_info()`:
+```python
+schema_info = f"""
+טבלת Feedback מכילה את השדות הבאים:
+- NewColumn: ...  # הוסף כאן
+"""
 ```
-(Note: repo size will increase; acceptable for small indices.)
 
-5) Option B: Keep index uncommitted; mount it on Runpod
-- Upload the `.vector_index/` folder to a Runpod volume mounted at `/workspace/.vector_index`
-- Set env vars if you changed paths:
-  - `VECTOR_INDEX_PATH=/workspace/.vector_index/faiss.index`
-  - `VECTOR_METADATA_PATH=/workspace/.vector_index/meta.parquet`
+## Troubleshooting
 
-With either option, the API will be immediately queryable without calling `/ingest`.
+### שגיאת "No feedback data available"
+- ודא שקובץ `Feedback.csv` קיים
+- ודא שהעמודות הנדרשות קיימות: ID, ServiceName, Level, Text
 
-### When your data changes
-- If you update `Feedback.csv` (or change `CSV_PATH` to a new dataset), you must rerun:
-```
-uv run -m scripts.precompute_index
-```
-- Then redeploy (bake new files into the image or upload to your Runpod volume) so the server uses the fresh index.
+### שגיאת API Key
+- ודא שקובץ `.env` קיים עם `GEMINI_API_KEY` או `OPENAI_API_KEY`
+
+### תשובות לא איכותיות
+- בדוק את הלוגים - המערכת מדפיסה ציוני איכות
+- נסה לשנות את ה-prompt ב-`_synthesize_answer()`
+
+## קישורים
+
+- GitHub: [לעדכן]
+- קורות חיים: [לעדכן]
 
-### Adding new feedback entries
-- You can add rows to `Feedback.csv` and either:
-  - Rebuild the entire index (simple, safest):
-    - `uv run -m scripts.precompute_index`
-  - Or implement an incremental append (advanced): embed only the new rows with `EmbeddingModel.encode(...)`, call `FaissVectorStore.load(...)`, then `store.add(new_vectors, new_metadata)` and `store.save(...)`. This keeps the same architecture and avoids re-embedding all previous data.
+## רישיון
 
+[לעדכן]

README_TESTING_GUIDE.md

@@ -1,520 +0,0 @@
-# Complete Testing & Deployment Guide
-
-Welcome! This is your comprehensive guide to testing the Feedback Analysis RAG Agent locally and deploying it to Runpod. Start here.
-
----
-
-## 🎯 Quick Navigation
-
-Choose your path:
-
-### 🏃 Fast Track (10-15 minutes)
-**I want to quickly verify everything works:**
-1. Read: ["Quick Start in 3 Steps"](#quick-start-in-3-steps) below
-2. Run: `python3 scripts/validate_local.py`
-3. Start: `python3 run.py`
-4. Test: Open http://localhost:8000/docs
-
-### 🧪 Thorough Testing (30-45 minutes)
-**I want to validate every feature:**
-1. Follow: **TESTING_CHECKLIST.md** (15 comprehensive tests)
-2. Test all endpoints (health, query, topics, sentiment, ingest)
-3. Verify Hebrew support and counting accuracy
-4. Run performance benchmarks
-
-### 🚀 Full Deployment (2 hours)
-**I want to deploy to Runpod:**
-1. Complete testing above
-2. Follow: **DEPLOYMENT_GUIDE.md** (step-by-step cloud setup)
-3. Build Docker image
-4. Deploy to Runpod
-5. Test cloud endpoint
-
-### 📚 Learn More (ongoing)
-**I want to understand the system:**
-1. Read: **SESSION_SUMMARY.md** (architecture overview)
-2. Read: **QUICK_START.md** (setup details)
-3. Check: **CONTRIBUTING.md** (development workflow)
-4. Explore: Source code in `app/` directory
-
----
-
-## ⚡ Quick Start in 3 Steps
-
-### Step 1: Validate Everything (2 minutes)
-```bash
-cd /Users/galbd/Desktop/personal/software/ai_agent_gov/Feedback_Analysis_RAG_Agent_runpod
-source .venv/bin/activate
-python3 scripts/validate_local.py
-```
-
-**Expected output:**
-```
-[PASS] Dependencies
-[PASS] CSV file
-[PASS] FAISS Index
-[PASS] App imports
-[PASS] Analysis logic
-[PASS] RAGService
-[PASS] API endpoints
-
-All 7 checks PASSED! Ready for local testing.
-```
-
-### Step 2: Start Server (1 minute)
-```bash
-python3 run.py
-```
-
-**Expected output:**
-```
-INFO:     Uvicorn running on http://0.0.0.0:8000
-INFO:     Application startup complete
-```
-
-### Step 3: Test an Endpoint (1 minute)
-
-**Option A - Browser (easiest):**
-```
-Open: http://localhost:8000/docs
-Click on /query endpoint
-Enter: {"query":"כמה משתמשים כתבו תודה","top_k":5}
-Click "Try it out"
-```
-
-**Option B - curl:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"כמה משתמשים כתבו תודה","top_k":5}'
-```
-
-**Expected:**
-```json
-{
-  "query": "כמה משתמשים כתבו תודה",
-  "summary": "1168 משובים מכילים ביטויי תודה.",
-  "results": [...]
-}
-```
-
-✅ **If you see this, the system is working!**
-
----
-
-## 📖 Documentation Map
-
-### For Setup & Running
-- **QUICK_START.md** - How to set up environment and run locally
-  - Prerequisites
-  - Virtual environment setup
-  - Dependency installation
-  - Server startup
-  - Basic testing
-
-### For Testing
-- **TESTING_CHECKLIST.md** - Complete 15-test validation suite
-  - Pre-flight checks
-  - All endpoint tests
-  - Performance benchmarks
-  - Error handling tests
-  - Results sign-off
-
-### For Deployment
-- **DEPLOYMENT_GUIDE.md** - How to deploy to Runpod
-  - Docker image creation
-  - Registry setup (Docker Hub)
-  - Runpod template creation
-  - Endpoint testing
-  - Monitoring & scaling
-  - Troubleshooting
-
-### For Understanding
-- **SESSION_SUMMARY.md** - Complete project overview
-  - What was delivered
-  - Technical specifications
-  - Project structure
-  - Validation results
-  - Feature list
-
-### For Development
-- **CONTRIBUTING.md** - Git workflow and development
-  - Branch naming
-  - Commit conventions
-  - Pull requests
-  - Code review process
-
----
-
-## 🏗️ System Architecture
-
-```
-┌─────────────────────────────────────────┐
-│         FastAPI Server (8000)           │
-├─────────────────────────────────────────┤
-│  5 Endpoints (all POST)                 │
-│  • /health - Server status              │
-│  • /query - Main RAG endpoint           │
-│  • /topics - Topic extraction           │
-│  • /sentiment - Sentiment analysis      │
-│  • /ingest - Index rebuilding           │
-└────────────┬────────────────────────────┘
-             │
-┌────────────▼────────────────────────────┐
-│      RAG Service Layer                  │
-├─────────────────────────────────────────┤
-│  • Intent Detection (count vs search)   │
-│  • Vector Embeddings (multilingual)     │
-│  • FAISS Search (semantic matching)     │
-│  • LLM Summarization (optional)         │
-└────────────┬────────────────────────────┘
-             │
-┌────────────▼────────────────────────────┐
-│        Data Layer                       │
-├─────────────────────────────────────────┤
-│  • CSV: 9930 feedback records           │
-│  • FAISS Index: 14.5 MB                 │
-│  • Metadata: 450 KB parquet             │
-└─────────────────────────────────────────┘
-```
-
----
-
-## 📊 What You're Testing
-
-### 1. **Data Integrity**
-- CSV loads correctly (9930 rows, 8 columns)
-- FAISS index valid (14.5 MB)
-- Metadata complete (parquet file)
-
-### 2. **Core Functionality**
-- Intent detection works (count vs. semantic)
-- Embeddings generated correctly
-- Vector search returns relevant results
-- Summaries generated accurately
-
-### 3. **API Endpoints**
-- All 5 endpoints respond (health, query, topics, sentiment, ingest)
-- Request validation works
-- Error handling proper
-- JSON serialization correct
-
-### 4. **Multi-Language Support**
-- Hebrew queries processed
-- English queries processed
-- Auto-detection of language
-- Responses in same language as query
-
-### 5. **Accuracy**
-- Thank-you count: **1168** ✓
-- Complaint count: **352** ✓
-- Total records: **9930** ✓
-
-### 6. **Performance**
-- Health check: <10ms
-- Query endpoint: 1-3 seconds
-- Sentiment analysis: 5-15 seconds per 100 records
-- Index rebuild: 30-60 seconds
-
----
-
-## 🧪 Test Levels
-
-### Level 1: Smoke Test (5 minutes)
-Quick sanity check that everything basically works:
-```bash
-python3 scripts/validate_local.py    # All 7 checks pass
-python3 run.py                        # Server starts
-curl http://localhost:8000/health    # Returns 200
-```
-
-### Level 2: Functional Test (15 minutes)
-Test each endpoint individually:
-```bash
-# Use Swagger UI or curl commands from TESTING_CHECKLIST.md
-# Test: health, query, topics, sentiment, ingest
-```
-
-### Level 3: Comprehensive Test (45 minutes)
-Full validation using TESTING_CHECKLIST.md:
-- All endpoint combinations
-- Error handling
-- Performance benchmarks
-- Data accuracy verification
-
-### Level 4: Load Testing (optional, 30 minutes)
-Stress test the system:
-```bash
-# Use Apache Bench or similar
-ab -n 100 -c 10 http://localhost:8000/health
-```
-
----
-
-## ✅ Success Criteria
-
-**You know the system is working when:**
-
-1. ✅ `validate_local.py` shows: **All 7 checks PASSED**
-2. ✅ Server starts: `python3 run.py` shows **"Application startup complete"**
-3. ✅ `/health` responds: Status **200**, response **`{"status":"ok"}`**
-4. ✅ `/query` responds: Returns count **1168** for thank-yous query
-5. ✅ `/topics` responds: Returns **5 topics** with relevant words
-6. ✅ `/sentiment` responds: Returns **50+ results** with labels
-7. ✅ Hebrew text: Query in Hebrew, response in Hebrew
-8. ✅ Response times: Query endpoint <3 seconds
-
----
-
-## 🚀 Common Tasks
-
-### Start Fresh
-```bash
-# Activate environment
-source .venv/bin/activate
-
-# Clear cache (optional)
-find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
-
-# Validate
-python3 scripts/validate_local.py
-
-# Run
-python3 run.py
-```
-
-### Rebuild Index
-```bash
-# Kill server (CTRL+C in running terminal)
-
-# Via API
-curl -X POST http://localhost:8000/ingest
-
-# Or via script
-python3 scripts/precompute_index.py
-```
-
-### Test Specific Endpoint
-```bash
-# With curl (health example)
-curl -X POST http://localhost:8000/health
-
-# With Python
-python3 -c "import requests; print(requests.post('http://localhost:8000/health').json())"
-
-# With Swagger UI
-# Open http://localhost:8000/docs
-```
-
-### Check Response Times
-```bash
-time curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"test","top_k":5}'
-```
-
-### View Server Logs
-```bash
-# Logs appear in the terminal running python3 run.py
-# For file logs, edit app/api.py to add logging
-```
-
----
-
-## ⚠️ Troubleshooting
-
-### Problem: Environment not activated
-```
-Error: No module named 'fastapi'
-```
-**Fix:** Activate virtual environment
-```bash
-source .venv/bin/activate
-```
-
-### Problem: Index file missing
-```
-FileNotFoundError: Vector index not found
-```
-**Fix:** Rebuild index
-```bash
-curl -X POST http://localhost:8000/ingest
-```
-
-### Problem: First request slow
-```
-Takes 20-30 seconds
-```
-**Fix:** Normal - models download first time. Subsequent requests faster.
-
-### Problem: Port already in use
-```
-Address already in use
-```
-**Fix:** Kill other process or use different port
-```bash
-# Find process using port 8000
-lsof -i :8000
-kill -9 <PID>
-
-# Or start on different port
-uvicorn app.api:app --port 8001
-```
-
-### Problem: CSV file not found
-```
-FileNotFoundError: Feedback.csv not found
-```
-**Fix:** Make sure you're in correct directory
-```bash
-cd /Users/galbd/Desktop/personal/software/ai_agent_gov/Feedback_Analysis_RAG_Agent_runpod
-ls -la Feedback.csv  # Should exist
-```
-
-**See more troubleshooting in:**
-- QUICK_START.md - Troubleshooting section
-- TESTING_CHECKLIST.md - Error handling section
-- DEPLOYMENT_GUIDE.md - Troubleshooting section
-
----
-
-## 📋 Pre-Testing Checklist
-
-Before you start testing:
-
-- [ ] Virtual environment created: `python3 -m venv .venv`
-- [ ] Virtual environment activated: `source .venv/bin/activate`
-- [ ] Dependencies installed: `pip install -r requirements.txt`
-- [ ] CSV file exists: `ls Feedback.csv` shows file
-- [ ] FAISS index exists: `ls .vector_index/faiss.index` shows file
-- [ ] Python version 3.10+: `python3 --version`
-- [ ] Enough disk space: `df -h` shows >1GB free
-- [ ] Enough RAM: `free -h` shows >4GB available
-
----
-
-## 🎯 Testing Path by Role
-
-### 👨‍💻 **Developer**
-1. QUICK_START.md - Set up local environment
-2. TESTING_CHECKLIST.md - Test all endpoints
-3. app/ - Explore source code
-4. Make changes, re-test
-5. CONTRIBUTING.md - Commit and push
-
-### 👨‍💼 **Operations/DevOps**
-1. QUICK_START.md - Verify local setup works
-2. DEPLOYMENT_GUIDE.md - Deploy to Runpod
-3. Set up monitoring and alerts
-4. Document runbook
-
-### 🧑‍🔬 **Data Analyst**
-1. QUICK_START.md - Get server running
-2. Test `/query` endpoint with various questions
-3. Test `/topics` endpoint for insight extraction
-4. Test `/sentiment` endpoint for emotion analysis
-5. Verify counts match CSV data
-
-### 👤 **End User**
-1. Get endpoint URL from your ops team
-2. Follow API examples in QUICK_START.md
-3. Use Swagger UI: `/docs` endpoint
-4. Ask questions in Hebrew or English
-5. Get answers via REST API
-
----
-
-## 📞 Need Help?
-
-### Quick Questions
-- Check: **QUICK_START.md** - Most common issues answered
-- Check: **TESTING_CHECKLIST.md** - Test-specific questions
-
-### Deployment Issues
-- Read: **DEPLOYMENT_GUIDE.md** - Troubleshooting section
-- Check: **Runpod documentation** - https://docs.runpod.io
-
-### Code Questions
-- Read: **SESSION_SUMMARY.md** - Architecture overview
-- Check: **Module docstrings** - `app/*.py` files have documentation
-
-### Still Stuck?
-1. Run validation: `python3 scripts/validate_local.py`
-2. Check error message
-3. Read relevant documentation section
-4. Try workaround from Troubleshooting
-
----
-
-## 🏁 Next Steps
-
-### After Testing Locally ✅
-1. All 7 validation checks pass
-2. All 5 endpoints respond correctly
-3. Hebrew queries work
-4. Counts are accurate (1168, 352)
-
-### Ready to Deploy? 🚀
-1. Follow DEPLOYMENT_GUIDE.md
-2. Build Docker image
-3. Push to Docker registry
-4. Create Runpod endpoint
-5. Test cloud deployment
-
-### In Production 📊
-1. Monitor response times
-2. Check error logs
-3. Set up auto-scaling
-4. Configure backups
-5. Plan upgrades
-
----
-
-## 📚 Document Reference
-
-| Document | Purpose | Read Time |
-|----------|---------|-----------|
-| **This file** | Navigation guide | 5 min |
-| **QUICK_START.md** | Local setup | 10 min |
-| **TESTING_CHECKLIST.md** | Full validation | 30-45 min |
-| **DEPLOYMENT_GUIDE.md** | Cloud deployment | 30-60 min |
-| **SESSION_SUMMARY.md** | Project overview | 10 min |
-| **CONTRIBUTING.md** | Development workflow | 5 min |
-| **README.md** | Full documentation | 20 min |
-
----
-
-## ✨ Final Checklist Before Going Live
-
-- [ ] Local validation: All 7 checks ✅
-- [ ] All endpoints tested: 5/5 working ✅
-- [ ] Response times acceptable: <3s for query ✅
-- [ ] Hebrew support verified: ✅
-- [ ] Counts accurate: 1168/352/9930 ✅
-- [ ] Error handling works: ✅
-- [ ] Docker image builds: ✅
-- [ ] Runpod deployed successfully: ✅
-- [ ] Cloud endpoint tested: ✅
-- [ ] Monitoring configured: ✅
-- [ ] Documentation complete: ✅
-- [ ] Backups ready: ✅
-
----
-
-## 🎉 Ready to Begin?
-
-**Start here based on what you want to do:**
-
-1. **Just verify it works:** `python3 scripts/validate_local.py` → Start server → Test one endpoint
-2. **Full validation:** Read TESTING_CHECKLIST.md and follow all 15 tests
-3. **Deploy to cloud:** Read DEPLOYMENT_GUIDE.md for step-by-step instructions
-4. **Understand the system:** Read SESSION_SUMMARY.md for architecture details
-
----
-
-*Last Updated: Today*  
-*Version: 1.0*  
-*Status: Production Ready* ✨
-
-**Your feedback analysis system is ready to use!** 🚀
-

SESSION_SUMMARY.md

@@ -1,371 +0,0 @@
-# Session Summary - Feedback Analysis RAG Agent
-
-## 🎯 Mission Accomplished
-
-You now have a **fully functional, locally-tested Feedback Analysis RAG Agent** that:
-- ✅ Answers diverse question types (counting, keyword search, semantic analysis)
-- ✅ Understands Hebrew queries natively
-- ✅ Provides accurate counts (1168 thank-yous, 352 complaints from 9930 feedback records)
-- ✅ Returns results in the query language
-- ✅ Works locally with comprehensive validation
-- ✅ Preserves cloud deployment capability (Runpod-ready)
-
----
-
-## 📦 What Was Delivered
-
-### 1. **Core RAG Pipeline** (Production-Ready)
-- Query intent detection (counts vs. semantic search)
-- FAISS vector search with multilingual embeddings
-- Multi-language support (Hebrew, English, etc.)
-- Results with semantic relevance scores
-
-### 2. **API Server** (All Endpoints Tested)
-- `/health` - Server status check
-- `/query` - Main RAG endpoint (intent-aware, counts/search)
-- `/topics` - Topic extraction (5 topics by default)
-- `/sentiment` - Sentiment analysis (50-500 records)
-- `/ingest` - Index rebuilding (one-time or maintenance)
-
-### 3. **Local Development Setup**
-- Virtual environment configuration
-- All dependencies installed and validated
-- Pre-computed FAISS index (14.5 MB)
-- Metadata storage (parquet format, 450 KB)
-- Environment template (`.env.example`)
-
-### 4. **Documentation**
-- **QUICK_START.md** - Setup and local testing in 5 steps
-- **TESTING_CHECKLIST.md** - Comprehensive validation guide (15 tests)
-- **CONTRIBUTING.md** - Git workflow and deployment procedures
-- **Module docstrings** - Every Python file documented
-
-### 5. **Validation & Testing**
-- **validate_local.py** - 7-check harness (all PASS ✅)
-  1. Dependencies check
-  2. CSV validation
-  3. FAISS index verification
-  4. Python imports test
-  5. Analysis logic validation
-  6. RAGService integration test
-  7. All API endpoints functional test
-
----
-
-## 🔧 Technical Specifications
-
-### Stack
-- **Framework:** FastAPI 0.115.5 + Uvicorn 0.32.0
-- **Vector DB:** FAISS 1.8.0 (CPU, IndexFlatIP)
-- **Embeddings:** Sentence-Transformers 3.1.1 (paraphrase-multilingual-MiniLM-L12-v2)
-- **Language Detection:** langdetect 1.0.9
-- **Sentiment:** Transformers 4.45.2 (nlptown/bert-base-multilingual-uncased-sentiment)
-- **ML:** scikit-learn 1.5.2 (k-means clustering for topics)
-- **Data:** Pandas 2.2.3, PyArrow 14.0.2
-- **Serialization:** orjson 3.10.7 (handles numpy types)
-
-### Data
-- **CSV:** 9930 rows of feedback records
-- **Index:** FAISS binary format (14.5 MB)
-- **Metadata:** Parquet format (450 KB)
-- **Columns:** ID, ServiceName, Level, Text, + 4 others
-
-### Performance
-- `/health` endpoint: <10ms
-- `/query` endpoint: 1-3 seconds (first call slower due to model load)
-- `/sentiment` endpoint: 5-15 seconds for 100 records
-- Index rebuild (`/ingest`): 30-60 seconds
-
----
-
-## ✨ Key Features
-
-### 1. Intent Detection
-The system automatically detects query type:
-- **Count queries:** "כמה משתמשים כתבו תודה?" → Returns count with examples
-- **Complaint queries:** "כמה תלונות?" → Counts complaints
-- **Keyword queries:** "cannabis" → Semantic search
-- **Free-form:** Any other question → RAG-based summarization
-
-### 2. Multi-Language Support
-- Queries can be in **Hebrew or English**
-- Responses auto-adapt to query language
-- All text properly encoded (no corruption)
-
-### 3. Result Quality
-- Semantic relevance scores (0-1)
-- Top results ranked by similarity
-- Full feedback context (service, level, text)
-- Accurate counting (validated against CSV)
-
-### 4. Error Handling
-- Clear error messages for invalid requests
-- HTTP status codes (200, 400, 422, 500)
-- Graceful fallbacks (if model fails, returns mock data)
-
----
-
-## 📋 Validation Results
-
-**Last Run:** ✅ ALL 7 CHECKS PASSED
-
-```
-[PASS] Dependencies - All 15+ packages installed
-[PASS] CSV file - 9930 rows, 8 columns
-[PASS] FAISS Index - 14.5 MB ready
-[PASS] App imports - No import errors
-[PASS] Analysis logic - Thanks: 1168 ✓, Complaints: 352 ✓
-[PASS] RAGService - Query endpoint functional
-[PASS] API endpoints - All 5 endpoints responding
-
-Status: Ready for local testing
-```
-
----
-
-## 🚀 Quick Start (For Your Testing)
-
-### Step 1: Activate Environment
-```bash
-cd /Users/galbd/Desktop/personal/software/ai_agent_gov/Feedback_Analysis_RAG_Agent_runpod
-source .venv/bin/activate
-```
-
-### Step 2: Validate Everything
-```bash
-python3 scripts/validate_local.py
-```
-*(Should show: All 7 checks PASSED)*
-
-### Step 3: Start Server
-```bash
-python3 run.py
-```
-*(Will show: "Uvicorn running on http://0.0.0.0:8000")*
-
-### Step 4: Test via Browser or curl
-**Browser:** http://localhost:8000/docs (interactive Swagger UI)
-
-**curl example:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"כמה משתמשים כתבו תודה","top_k":5}'
-```
-
-### Step 5: Run Full Test Suite
-See **TESTING_CHECKLIST.md** for 15 comprehensive tests.
-
----
-
-## 📁 Project Structure
-
-```
-Feedback_Analysis_RAG_Agent_runpod/
-├── app/                          # Main application
-│   ├── __init__.py              # Package init with docstring
-│   ├── api.py                   # FastAPI endpoints (all POST)
-│   ├── config.py                # Configuration & settings
-│   ├── rag_service.py           # RAG orchestration (answer() method)
-│   ├── analysis.py              # Query intent detection & counting
-│   ├── embedding.py             # Sentence-Transformers wrapper
-│   ├── vector_store.py          # FAISS interface
-│   ├── sentiment.py             # Sentiment analysis pipeline
-│   ├── preprocess.py            # Text preprocessing
-│   ├── data_loader.py           # CSV loading & caching
-│   ├── topics.py                # Topic clustering (k-means)
-│   └── __pycache__/
-│
-├── scripts/
-│   ├── validate_local.py        # 7-check validation harness ✅
-│   ├── precompute_index.py      # Build index offline
-│   ├── test_queries.py          # Manual query testing
-│   └── __pycache__/
-│
-├── .vector_index/
-│   ├── faiss.index              # FAISS index binary (14.5 MB)
-│   └── meta.parquet             # Metadata (450 KB)
-│
-├── .venv/                        # Python virtual environment
-│
-├── Dockerfile                    # Container definition
-├── docker-compose.yml            # Local docker-compose (optional)
-├── requirements.txt              # Python dependencies (25 packages)
-├── run.py                        # Server entrypoint
-├── Feedback.csv                  # Sample data (9930 rows)
-│
-├── QUICK_START.md               # 5-step local setup guide ✅
-├── TESTING_CHECKLIST.md         # 15-test validation guide ✅
-├── CONTRIBUTING.md              # Git workflow & deployment ✅
-├── README.md                     # Full documentation
-├── VERSION                       # Version file (0.1.0)
-├── .env.example                 # Environment template ✅
-│
-├── .git/                        # Git repository
-└── .gitignore
-
-```
-
----
-
-## 📝 Recent Changes (This Session)
-
-### Fixed Issues
-1. ✅ **Missing tiktoken dependency** - Added to requirements.txt
-2. ✅ **Sentiment model compatibility** - Switched to nlptown/bert-base-multilingual-uncased-sentiment (more compatible)
-3. ✅ **Numpy serialization** - All endpoints use ORJSONResponse + float/str conversions
-4. ✅ **Validation failures** - Now all 7 checks pass
-
-### Files Modified
-- `requirements.txt` - Added `tiktoken==0.7.0`
-- `app/sentiment.py` - Improved model loading with fallbacks
-- `TESTING_CHECKLIST.md` - Created (comprehensive guide)
-
-### Files Created
-- `TESTING_CHECKLIST.md` - 15-step testing guide
-- `SESSION_SUMMARY.md` - This file
-
----
-
-## 🧪 Testing Approach
-
-The system has **3 layers of validation:**
-
-### Layer 1: Unit/Component Tests
-- CSV format validation
-- Index integrity check
-- Import verification
-- Individual module testing
-
-### Layer 2: Integration Tests
-- RAGService end-to-end
-- API endpoint responses
-- Intent detection accuracy
-
-### Layer 3: End-to-End Tests
-- Manual curl commands
-- Browser (Swagger UI) testing
-- Multiple query types
-- Performance benchmarks
-
----
-
-## 🔒 Data Safety
-
-- **Original CSV untouched** - No modifications to source data
-- **Index cached locally** - Pre-computed FAISS index (doesn't rebuild on every start)
-- **Metadata preserved** - Service names, levels, full text stored in parquet
-- **No data uploaded** - All processing local (unless LLM API is used for summaries)
-- **Secure defaults** - `.env.example` template (no real keys committed)
-
----
-
-## 🌐 Deployment Ready
-
-### For Local Testing
-✅ Everything ready - just run `python3 run.py`
-
-### For Runpod Cloud Deployment
-✅ Dockerfile preserved and functional
-- All code changes are local-only
-- Docker image builds without issues
-- Runpod instructions in README.md
-
-### For Multiple Environments
-✅ Configuration via environment variables
-- Model paths configurable
-- API keys optional (LLM summaries use cached models if keys unavailable)
-- Port/host configurable
-
----
-
-## 📊 Test Coverage
-
-| Component | Tests | Status |
-|-----------|-------|--------|
-| Dependencies | 1 | ✅ PASS |
-| CSV Data | 1 | ✅ PASS |
-| FAISS Index | 1 | ✅ PASS |
-| Python Imports | 1 | ✅ PASS |
-| Analysis Logic | 1 | ✅ PASS (1168/352 verified) |
-| RAGService | 1 | ✅ PASS |
-| API Endpoints | 5 | ✅ PASS |
-| **Total** | **15** | **✅ ALL PASS** |
-
----
-
-## 🎓 What You Can Now Do
-
-### As a Developer
-1. **Run locally** - Full server on your machine
-2. **Debug code** - Step through Python with your IDE
-3. **Modify queries** - Test different intent detection logic
-4. **Add features** - Topics, sentiment, custom analysis
-5. **Understand RAG** - See how embeddings + retrieval works
-
-### As a User
-1. **Ask questions** - Count thank-yous, find complaints, search topics
-2. **Get answers** - In Hebrew or English
-3. **Analyze data** - Topics, sentiment, patterns
-4. **Export results** - JSON format, easily integrated
-
-### For Deployment
-1. **Test thoroughly** - Use TESTING_CHECKLIST.md
-2. **Deploy locally** - Docker compose available
-3. **Deploy to cloud** - Runpod ready with Dockerfile
-4. **Monitor performance** - Response times, error rates
-
----
-
-## ⚠️ Known Limitations & Workarounds
-
-| Issue | Impact | Workaround |
-|-------|--------|-----------|
-| First request slow (model download) | 10-30s first time | Runs in background, cached after |
-| Sentiment model download large | ~500MB | Pre-download with precompute script |
-| Hebrew counting requires specific keywords | May miss some variations | Extend keywords in `analysis.py` |
-| No persistent server logs | Can't audit old requests | Add file logging if needed |
-
----
-
-## 🚀 Next Steps for You
-
-1. **Start the server:** `python3 run.py`
-2. **Open Swagger UI:** http://localhost:8000/docs
-3. **Run test checklist:** Use TESTING_CHECKLIST.md (15 tests)
-4. **Validate counts:** Confirm 1168 thanks, 352 complaints
-5. **Deploy to Runpod:** When satisfied, follow README.md
-
----
-
-## 📞 Support Resources
-
-- **QUICK_START.md** - How to set up and run
-- **TESTING_CHECKLIST.md** - How to validate
-- **CONTRIBUTING.md** - How to deploy
-- **README.md** - Full documentation
-- **Swagger UI** - Interactive API docs (http://localhost:8000/docs)
-
----
-
-## ✅ Sign-Off
-
-**Status:** ✅ **READY FOR YOUR TESTING**
-
-- All code complete and functional
-- All validation checks passing
-- Documentation comprehensive
-- Local environment configured
-- Cloud deployment prepared
-- Performance acceptable
-
-**Next action:** Start the server and run through TESTING_CHECKLIST.md
-
-**Estimated testing time:** 30-45 minutes (full suite) or 10-15 minutes (quick smoke test)
-
----
-
-*Generated: Today*  
-*Session: Feedback Analysis RAG Agent - Complete Implementation*  
-*Status: Production Ready ✨*
-

SQL_APPROACH_README.md

@@ -1,172 +0,0 @@
-# SQL-Based Approach - מדריך
-
-## סקירה כללית
-
-גישה חדשה לניתוח משובי משתמשים המבוססת על SQL queries שנוצרות אוטומטית על ידי LLM.
-
-## ארכיטקטורה
-
-### 1. ניתוח שאילתת המשתמש
-- המשתמש שואל שאלה בעברית או באנגלית
-- השאלה נשלחת ל-LLM לניתוח
-
-### 2. יצירת שאילתות SQL (1-5 שאילתות)
-**מיקום:** `app/sql_service.py` - `_generate_sql_queries()`
-
-המערכת משתמשת ב-LLM (Gemini או OpenAI) כדי ליצור 1-5 שאילתות SQL שיעזרו לענות על השאלה.
-
-**הפרומפט כולל:**
-- מידע על מבנה הטבלה (ID, ServiceName, Level, Text)
-- סטטיסטיקות כלליות
-- כללי SQLite
-- הוראות ליצירת שאילתות תקפות
-
-**דוגמאות לשאילתות שנוצרות:**
-```sql
-SELECT ServiceName, COUNT(*) as count, AVG(Level) as avg_level 
-FROM feedback 
-GROUP BY ServiceName 
-ORDER BY count DESC 
-LIMIT 10;
-
-SELECT Level, COUNT(*) as count 
-FROM feedback 
-WHERE Level < 3 
-GROUP BY Level;
-```
-
-### 3. הרצת השאילתות
-**מיקום:** `app/sql_service.py` - `_execute_sql_queries()`
-
-- יוצר SQLite in-memory database
-- טוען את ה-DataFrame לטבלה `feedback`
-- מריץ כל שאילתה ומחזיר תוצאות או שגיאות
-
-### 4. יצירת תשובה מסכמת
-**מיקום:** `app/sql_service.py` - `_synthesize_answer()`
-
-המערכת משתמשת ב-LLM (בתפקיד אנליסט עסקי במשרד הפנים) כדי ליצור תשובה מסכמת.
-
-**הפרומפט כולל:**
-- שאלת המשתמש
-- השאילתות שבוצעו
-- התוצאות של כל שאילתה
-- הוראות לכתיבת תשובה מפורטת ומקצועית
-
-**דרישות לתשובה:**
-- 5-7 פסקאות, 400-600 מילים
-- מספרים מדויקים מהתוצאות
-- תובנות עסקיות והמלצות מעשיות
-- מבנה ברור: פתיחה, ניתוח, תובנות, סיכום
-
-### 5. יצירת ויזואליזציות (אופציונלי)
-**מיקום:** `app/sql_service.py` - `_generate_visualizations()`
-
-המערכת מנתחת את תוצאות השאילתות ויוצרת מפרטי ויזואליזציות:
-
-**סוגי גרפיקות נתמכים:**
-- **Bar Chart** - לנתונים קטגוריאליים עם ערכים מספריים
-- **Line Chart** - לנתוני זמן או מגמות
-- **Scatter Plot** - לשני משתנים מספריים
-- **Histogram** - להפצת ערכים מספריים
-
-**Frontend:** משתמש ב-Chart.js להצגת הגרפיקות
-
-## שימוש
-
-### דרך API
-
-```bash
-POST /query-sql
-Content-Type: application/json
-
-{
-  "query": "איך המשתמשים מרגישים כלפי השירות?",
-  "top_k": 5
-}
-```
-
-**תגובה:**
-```json
-{
-  "query": "איך המשתמשים מרגישים כלפי השירות?",
-  "summary": "תשובה מסכמת מפורטת...",
-  "sql_queries": [
-    "SELECT Level, COUNT(*) FROM feedback GROUP BY Level",
-    "..."
-  ],
-  "query_results": [
-    {
-      "query": "SELECT ...",
-      "result": [...],
-      "error": null,
-      "row_count": 10
-    }
-  ],
-  "visualizations": [
-    {
-      "type": "bar",
-      "title": "תוצאה של שאילתה 1",
-      "x": "Level",
-      "y": "count",
-      "data": [...]
-    }
-  ]
-}
-```
-
-### דרך Frontend
-
-1. פתח את הדפדפן: `http://127.0.0.1:8000`
-2. בחר "SQL-based (מומלץ - חדש)"
-3. הזן שאלה
-4. לחץ על "שאל"
-5. התוצאות יוצגו עם:
-   - תשובה מסכמת
-   - שאילתות SQL שבוצעו (אם מסומן "הצג דוגמאות מהנתונים")
-   - תוצאות השאילתות
-   - גרפיקות אוטומטיות
-
-## יתרונות הגישה החדשה
-
-1. **דיוק גבוה** - שאילתות SQL מדויקות יותר מ-RAG
-2. **שקיפות** - המשתמש רואה בדיוק אילו שאילתות בוצעו
-3. **גמישות** - יכול לענות על שאלות מורכבות עם מספר שאילתות
-4. **ויזואליזציות** - גרפיקות אוטומטיות של התוצאות
-5. **מהירות** - שאילתות SQL מהירות יותר מ-RAG
-
-## השוואה לגישה הישנה (RAG)
-
-| תכונה | RAG | SQL-based |
-|------|-----|-----------|
-| דיוק | בינוני | גבוה |
-| שקיפות | נמוכה | גבוהה |
-| מהירות | איטית יותר | מהירה יותר |
-| גמישות | מוגבלת | גבוהה |
-| ויזואליזציות | לא | כן |
-
-## הגדרות LLM
-
-### יצירת שאילתות SQL
-- **Temperature:** 0.3 (נמוך לדיוק)
-- **Model:** Gemini 1.5 Flash או GPT-4o-mini
-
-### יצירת תשובה מסכמת
-- **Temperature:** 0.8 (גבוה ליצירתיות)
-- **Top_p:** 0.95
-- **Max tokens:** 4000 (Gemini) / 3000 (OpenAI)
-
-## קבצים רלוונטי��ם
-
-- `app/sql_service.py` - הלוגיקה הראשית
-- `app/api.py` - endpoint `/query-sql`
-- `app/static/app.js` - תמיכה frontend בגרפיקות
-- `app/static/index.html` - ממשק משתמש
-
-## הערות טכניות
-
-- המערכת משתמשת ב-SQLite in-memory database
-- הנתונים נטענים פעם אחת בתחילת הפעלה
-- השאילתות רצות על DataFrame דרך SQLite
-- הגרפיקות נוצרות אוטומטית על בסיס מבנה התוצאות
-

STATUS_REPORT.md

@@ -1,501 +0,0 @@
-# 📊 Project Status Report - November 12, 2025
-
-## ✅ COMPLETION STATUS: 100%
-
----
-
-## 🎯 Project Objectives - ALL ACHIEVED
-
-### Original Requirements
-- [x] RAG agent answers diverse question types ✅
-- [x] Intent detection for counting queries ✅
-- [x] Multi-language support (Hebrew + English) ✅
-- [x] Local development setup complete ✅
-- [x] Cloud deployment ready (Runpod) ✅
-- [x] Comprehensive validation testing ✅
-- [x] Complete documentation ✅
-
----
-
-## 📦 Deliverables
-
-### Core System (7 files in `app/`)
-```
-✅ api.py               - 5 POST endpoints, all tested
-✅ rag_service.py       - RAG orchestration with intent detection
-✅ analysis.py          - Query intent + counting logic
-✅ embedding.py         - Sentence-Transformers wrapper
-✅ vector_store.py      - FAISS interface
-✅ sentiment.py         - Multi-language sentiment analysis
-✅ config.py            - Configuration management
-+ 4 support modules    - (preprocess, data_loader, topics, __init__)
-```
-
-### Validation & Testing (3 files in `scripts/`)
-```
-✅ validate_local.py    - 7-check validation harness (ALL PASS)
-✅ precompute_index.py  - FAISS index builder
-✅ test_queries.py      - Manual query testing
-```
-
-### Documentation (6 comprehensive guides)
-```
-✅ README_TESTING_GUIDE.md  - Master navigation guide (THIS IS YOUR START)
-✅ QUICK_START.md           - 5-step local setup
-✅ TESTING_CHECKLIST.md     - 15-point comprehensive test suite
-✅ DEPLOYMENT_GUIDE.md      - Runpod cloud deployment
-✅ SESSION_SUMMARY.md       - Project overview & architecture
-✅ CONTRIBUTING.md          - Git workflow & development
-```
-
-### Infrastructure
-```
-✅ requirements.txt     - 26 dependencies (all installed & working)
-✅ Dockerfile           - Production-ready container
-✅ docker-compose.yml   - Local development (optional)
-✅ .env.example         - Configuration template
-✅ VERSION              - Version tracking (0.1.0)
-✅ run.py               - Server entrypoint
-```
-
-### Data & Index
-```
-✅ Feedback.csv         - 9930 rows of feedback
-✅ .vector_index/       - FAISS index (14.5 MB) + metadata (450 KB)
-```
-
----
-
-## 🧪 Validation Results
-
-### Last Validation Run
-```
-Date: November 12, 2025
-Command: python3 scripts/validate_local.py
-Status: ✅ ALL 7 CHECKS PASSED
-```
-
-**Detailed Results:**
-```
-[PASS] ✅ Dependencies      - 26/26 packages installed
-[PASS] ✅ CSV file         - 9930 rows, 8 columns verified
-[PASS] ✅ FAISS Index      - 14.5 MB ready for use
-[PASS] ✅ App imports      - No import errors
-[PASS] ✅ Analysis logic   - Thanks: 1168 ✓, Complaints: 352 ✓
-[PASS] ✅ RAGService       - Query endpoint functional
-[PASS] ✅ API endpoints    - All 5 endpoints responding correctly
-
-Execution Time: ~2 minutes
-Status: READY FOR PRODUCTION
-```
-
----
-
-## 🚀 API Endpoints - All Functional
-
-| Endpoint | Method | Status | Response Time | Purpose |
-|----------|--------|--------|----------------|---------|
-| `/health` | POST | ✅ | <10ms | Server health check |
-| `/query` | POST | ✅ | 1-3s | Main RAG endpoint |
-| `/topics` | POST | ✅ | 5-10s | Topic extraction |
-| `/sentiment` | POST | ✅ | 5-15s | Sentiment analysis |
-| `/ingest` | POST | ✅ | 30-60s | Index rebuilding |
-| `/docs` | GET | ✅ | <100ms | Swagger UI (interactive) |
-| `/redoc` | GET | ✅ | <100ms | ReDoc (alternative docs) |
-
----
-
-## 📊 Feature Matrix
-
-### Query Processing
-```
-✅ Intent Detection
-   - Count thank-yous ............................ WORKING
-   - Count complaints ............................ WORKING
-   - Keyword search ............................. WORKING
-   - Free-form RAG questions .................... WORKING
-
-✅ Multi-Language Support
-   - Hebrew queries ............................ WORKING
-   - English queries ........................... WORKING
-   - Language auto-detection ................... WORKING
-   - Response language matching ............... WORKING
-
-✅ Retrieval Accuracy
-   - Semantic search scores ................... ACCURATE
-   - Top-K ranking ............................ VERIFIED
-   - Count validation (1168/352) .............. VERIFIED
-```
-
-### Performance
-```
-✅ Response Times
-   - Health check: <10ms ...................... EXCELLENT
-   - Query endpoint: 1-3s ..................... GOOD
-   - Sentiment: 5-15s per 100 ................ ACCEPTABLE
-   - Index rebuild: 30-60s ................... ACCEPTABLE
-
-✅ Scalability
-   - Concurrent requests ..................... TESTED
-   - Auto-scaling ready ...................... CONFIGURED
-   - Memory efficient ........................ VERIFIED
-```
-
-### Reliability
-```
-✅ Error Handling
-   - Invalid JSON ............................ HANDLED
-   - Missing fields .......................... HANDLED
-   - Type errors ............................ HANDLED
-   - Model failures ......................... HANDLED
-
-✅ Data Integrity
-   - CSV validation ......................... VERIFIED
-   - Index integrity ........................ VERIFIED
-   - No data loss ........................... CONFIRMED
-```
-
----
-
-## 📈 Test Coverage
-
-```
-Layer 1: Unit Tests
-├─ CSV validation ................................. ✅ PASS
-├─ Index integrity ................................ ✅ PASS
-├─ Import verification ........................... ✅ PASS
-└─ Individual modules ............................ ✅ PASS
-
-Layer 2: Integration Tests
-├─ RAGService pipeline ........................... ✅ PASS
-├─ API endpoint responses ........................ ✅ PASS
-└─ Intent detection accuracy ..................... ✅ PASS
-
-Layer 3: End-to-End Tests
-├─ Manual curl commands .......................... ✅ PASS
-├─ Browser (Swagger UI) testing ................. ✅ PASS
-├─ Multiple query types ......................... ✅ PASS
-└─ Performance benchmarks ........................ ✅ PASS
-```
-
-**Overall Coverage:** 15/15 tests passing (100%)
-
----
-
-## 🔧 Technical Stack - Verified Working
-
-```
-✅ Framework:  FastAPI 0.115.5 + Uvicorn 0.32.0
-✅ ML:         Transformers 4.45.2 + PyTorch 2.4.1
-✅ Embeddings: Sentence-Transformers 3.1.1
-✅ Vector DB:  FAISS 1.8.0 (CPU)
-✅ Data:       Pandas 2.2.3 + PyArrow 14.0.2
-✅ Language:   langdetect 1.0.9
-✅ Config:     Pydantic 2.9.2 + python-dotenv 1.0.1
-✅ Serialization: orjson 3.10.7
-✅ LLM APIs:   Google Generative AI + OpenAI (optional)
-```
-
----
-
-## 📚 Documentation Quality
-
-### User Guides
-```
-✅ README_TESTING_GUIDE.md   - 500+ lines, comprehensive navigation
-✅ QUICK_START.md             - 400+ lines, step-by-step setup
-✅ TESTING_CHECKLIST.md       - 400+ lines, 15-point validation
-✅ DEPLOYMENT_GUIDE.md        - 470+ lines, Runpod instructions
-```
-
-### Technical Documentation
-```
-✅ SESSION_SUMMARY.md         - 400+ lines, architecture overview
-✅ CONTRIBUTING.md            - 150+ lines, development workflow
-✅ Module docstrings          - Every Python file documented
-✅ Inline comments            - Complex logic explained
-```
-
-### Code Quality
-```
-✅ Type hints              - Pydantic models for all API inputs/outputs
-✅ Error messages         - Clear, actionable error descriptions
-✅ Configuration          - Centralized in app/config.py
-✅ Logging               - Info/warning/error levels
-```
-
----
-
-## 🌐 Deployment Readiness
-
-### Local Development
-```
-✅ Virtual environment   - Configured (.venv/)
-✅ Dependencies         - All installed (26 packages)
-✅ Configuration        - Environment template (.env.example)
-✅ Database            - Pre-computed index ready
-✅ Server startup      - One command: python3 run.py
-```
-
-### Docker Containerization
-```
-✅ Dockerfile           - Production-ready Dockerfile
-✅ Image build          - Tested & working
-✅ Port exposure        - 8000 configured
-✅ Environment vars     - Passthrough configured
-```
-
-### Cloud Deployment (Runpod)
-```
-✅ Deployment guide     - Step-by-step instructions
-✅ Registry integration - Docker Hub ready
-✅ Template creation    - Documented procedure
-✅ Monitoring setup     - Logging configured
-```
-
----
-
-## 📋 Ready-to-Use Guides
-
-### For First-Time Users (START HERE)
-1. **README_TESTING_GUIDE.md** (5 min read)
-   - Shows what to do based on your role
-   - Links to relevant guides
-   - Quick 3-step verification
-
-### For Immediate Setup (10-15 min)
-2. **QUICK_START.md** (follow step-by-step)
-   - Python environment setup
-   - Dependency installation
-   - Server startup
-   - Basic testing
-
-### For Comprehensive Testing (30-45 min)
-3. **TESTING_CHECKLIST.md** (15 tests)
-   - All endpoint validation
-   - Performance benchmarks
-   - Error handling tests
-   - Results sign-off
-
-### For Cloud Deployment (2 hours)
-4. **DEPLOYMENT_GUIDE.md** (step-by-step)
-   - Docker image creation
-   - Registry setup
-   - Runpod template
-   - Cloud testing
-
----
-
-## ✨ Key Achievements
-
-### Code Quality
-- ✅ All imports validated (no missing packages)
-- ✅ No syntax errors (validated with Pylance)
-- ✅ Type hints throughout codebase
-- ✅ Comprehensive docstrings
-- ✅ Proper error handling with try/except
-
-### Functionality
-- ✅ Query intent detection works perfectly
-- ✅ Count accuracy verified (1168 thanks, 352 complaints)
-- ✅ Multi-language support confirmed (Hebrew + English)
-- ✅ All 5 API endpoints responding
-- ✅ FAISS index optimized and validated
-
-### Testing & Validation
-- ✅ 7/7 validation checks passing
-- ✅ All endpoints tested individually
-- ✅ Performance benchmarks acceptable
-- ✅ Error scenarios handled
-- ✅ End-to-end testing complete
-
-### Documentation
-- ✅ 6 comprehensive guides created
-- ✅ 1600+ lines of user documentation
-- ✅ Clear navigation and cross-references
-- ✅ Step-by-step instructions for all tasks
-- ✅ Troubleshooting sections included
-
-### Deployment
-- ✅ Docker image production-ready
-- ✅ Runpod deployment guide complete
-- ✅ Local and cloud paths preserved
-- ✅ No data or code conflicts
-- ✅ Ready for immediate deployment
-
----
-
-## 🎯 What's Working Perfectly
-
-### The RAG Pipeline
-```
-User Query
-    ↓
-Intent Detection (what type of question?)
-    ↓
-Count Query?     → Count from CSV (1168 thanks, 352 complaints)
-Semantic Query?  → Embed + FAISS search + LLM summary
-    ↓
-Response in same language as query
-    ↓
-JSON API response with results
-```
-
-### Count Accuracy
-```
-Query: "כמה משתמשים כתבו תודה"
-Expected: ~1168 records with thank-you keywords
-Actual: 1168 ✅
-Accuracy: 100% ✅
-```
-
-### Multi-Language Support
-```
-Hebrew Query  → Hebrew Response ✅
-English Query → English Response ✅
-Auto-Detection → Working ✅
-```
-
-### API Quality
-```
-All 5 endpoints responding ✅
-JSON serialization clean ✅
-Error messages clear ✅
-Response times acceptable ✅
-```
-
----
-
-## ⚠️ Known Limitations (Minor)
-
-| Limitation | Impact | Workaround |
-|-----------|--------|-----------|
-| First request slow (model download) | 10-30s | Subsequent requests cached |
-| Sentiment model ~500MB | Storage | Pre-download in Dockerfile |
-| Hebrew variants not captured | Counts may miss variations | Extend keywords in analysis.py |
-| No persistent audit logs | Can't review old requests | Add file logging if needed |
-
-**Impact Level:** LOW - All limitations are manageable and documented
-
----
-
-## 🚀 Next Actions for You
-
-### Immediate (Today)
-1. Read: **README_TESTING_GUIDE.md** (5 min)
-2. Run: `python3 scripts/validate_local.py` (2 min)
-3. Start: `python3 run.py` (1 min)
-4. Test: Open http://localhost:8000/docs (2 min)
-
-### Short-term (This week)
-1. Follow: **TESTING_CHECKLIST.md** (45 min)
-2. Verify: All 15 tests passing
-3. Try: Different query types and languages
-
-### Medium-term (When ready)
-1. Follow: **DEPLOYMENT_GUIDE.md** (2 hours)
-2. Build: Docker image locally
-3. Deploy: To Runpod
-4. Test: Cloud endpoint
-
----
-
-## 📞 Support & Troubleshooting
-
-**Quick help:**
-- Most questions answered in: **QUICK_START.md**
-- Testing issues: **TESTING_CHECKLIST.md**
-- Deployment issues: **DEPLOYMENT_GUIDE.md**
-- Architecture questions: **SESSION_SUMMARY.md**
-
-**Common issues:**
-1. Environment not activated → See QUICK_START.md
-2. Index not found → Run: `curl -X POST http://localhost:8000/ingest`
-3. Port in use → Use different port or kill process
-4. Slow first request → Normal, model downloads first time
-
----
-
-## 📊 Project Metrics
-
-```
-Code Statistics
-├─ Python files: 11 (app/ + scripts/)
-├─ Lines of code: ~2000 (excluding venv)
-├─ Documentation files: 6
-├─ Documentation lines: 1600+
-└─ Test coverage: 100%
-
-Performance
-├─ Health check: <10ms
-├─ Query endpoint: 1-3 seconds
-├─ Sentiment analysis: 5-15 seconds
-└─ Index build: 30-60 seconds
-
-Data
-├─ Feedback records: 9930
-├─ Unique services: 100+
-├─ FAISS index size: 14.5 MB
-└─ Metadata size: 450 KB
-
-Testing
-├─ Validation checks: 7/7 PASS
-├─ API endpoints: 5/5 PASS
-├─ End-to-end tests: 15/15 PASS
-└─ Overall: 100% ✅
-```
-
----
-
-## ✅ Final Checklist
-
-- [x] All code complete and tested
-- [x] All validation checks passing
-- [x] All documentation written
-- [x] Local setup instructions clear
-- [x] Cloud deployment guide ready
-- [x] Git repository clean
-- [x] Dependencies frozen in requirements.txt
-- [x] Docker image production-ready
-- [x] Runpod deployment documented
-- [x] Troubleshooting guide included
-- [x] Performance acceptable
-- [x] Security considerations noted
-- [x] Scalability path clear
-- [x] Backup strategy documented
-- [x] Monitoring setup documented
-
-**Status:** ✅ **ALL ITEMS COMPLETE**
-
----
-
-## 🎓 Summary
-
-You have a **production-ready Feedback Analysis RAG Agent** that:
-
-✅ **Works locally** - Full development environment set up  
-✅ **Works in the cloud** - Runpod deployment ready  
-✅ **Answers diverse questions** - Intent detection + RAG pipeline  
-✅ **Supports multiple languages** - Hebrew and English  
-✅ **Is well-documented** - 1600+ lines of guides  
-✅ **Is thoroughly tested** - 15-point validation suite  
-✅ **Is maintainable** - Clean code with docstrings  
-
----
-
-## 🎉 Thank You!
-
-The system is **ready for your testing**. Choose your path:
-
-- **Quick verification:** Start with README_TESTING_GUIDE.md (5 min)
-- **Full testing:** Follow TESTING_CHECKLIST.md (45 min)
-- **Deployment:** Use DEPLOYMENT_GUIDE.md (2 hours)
-
-**Status:** ✨ **PRODUCTION READY** ✨
-
----
-
-*Report Generated: November 12, 2025*  
-*Project Status: 100% Complete*  
-*Ready for: Immediate Production Use*
-

TESTING_CHECKLIST.md

@@ -1,472 +0,0 @@
-# Testing Checklist - Comprehensive Validation
-
-This document walks you through testing all components of the Feedback Analysis RAG Agent locally before deployment.
-
-## ✅ Pre-Flight Checks (5 mins)
-
-### 1. Environment Setup
-- [ ] Python 3.11+ installed: `python3 --version`
-- [ ] Virtual environment activated: `source .venv/bin/activate`
-- [ ] All dependencies installed: `pip list | grep -E "fastapi|pandas|faiss|sentence-transformers"`
-- [ ] CSV file exists: `ls -lh Feedback.csv` (should be ~2-3 MB, 9930 rows)
-- [ ] FAISS index exists: `ls -lh .vector_index/` (should have `faiss.index` and `meta.parquet`)
-
-### 2. Run Validation Harness
-```bash
-python3 scripts/validate_local.py
-```
-
-**Expected Output:**
-```
-[PASS] Dependencies
-[PASS] CSV file
-[PASS] FAISS Index
-[PASS] App imports
-[PASS] Analysis logic
-[PASS] RAGService
-[PASS] API endpoints
-
-------------------------------------------------------------
-All 7 checks PASSED! Ready for local testing.
-```
-
-- [ ] All 7 checks pass
-- [ ] No error messages
-- [ ] Takes 2-3 minutes total
-
-**If any check fails:** See the error message and check QUICK_START.md troubleshooting section.
-
----
-
-## 🚀 Server Startup (2 mins)
-
-### 3. Start the API Server
-```bash
-python3 run.py
-```
-
-**Expected Output:**
-```
-INFO:     Uvicorn running on http://0.0.0.0:8000
-INFO:     Application startup complete
-```
-
-- [ ] Server starts without errors
-- [ ] Listens on `http://0.0.0.0:8000`
-- [ ] No red error messages
-- [ ] Can see "Application startup complete"
-
-**Keep this terminal open.** Open a NEW terminal for tests.
-
----
-
-## 🧪 Endpoint Testing (10-15 mins)
-
-### 4. Test `/health` Endpoint
-
-**Via curl:**
-```bash
-curl -X POST http://localhost:8000/health
-```
-
-**Expected Response:**
-```json
-{"status":"ok"}
-```
-
-- [ ] Status code: 200
-- [ ] Response: `{"status":"ok"}`
-
-**Via Swagger UI:**
-- [ ] Open http://localhost:8000/docs
-- [ ] Find `/health` endpoint
-- [ ] Click "Try it out" → "Execute"
-- [ ] Response 200 with status
-
----
-
-### 5. Test `/query` Endpoint - Count Thank-yous
-
-**Via curl:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"כמה משתמשים כתבו תודה","top_k":2}'
-```
-
-**Expected Response:**
-```json
-{
-  "query": "כמה משתמשים כתבו תודה",
-  "summary": "1168 משובים מכילים ביטויי תודה.",
-  "results": [
-    {
-      "score": 0.808,
-      "service": "CannabisUpdate@health.gov.il",
-      "level": "5",
-      "text": "נח וידידותי למשתמש - תודה"
-    },
-    ...
-  ]
-}
-```
-
-**Check these:**
-- [ ] Status code: 200
-- [ ] Summary contains count: "1168"
-- [ ] Summary in Hebrew (עברית)
-- [ ] Has 2 results (top_k=2)
-- [ ] Each result has: score, service, level, text
-- [ ] Scores are between 0 and 1
-
----
-
-### 6. Test `/query` Endpoint - Count Complaints
-
-**Via curl:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"כמה משתמשים מתלוננים על בעיות במערכת","top_k":3}'
-```
-
-**Expected Response:**
-- [ ] Status code: 200
-- [ ] Summary contains complaint count (~352)
-- [ ] Has 3 results
-- [ ] Results contain complaint-related feedback
-
----
-
-### 7. Test `/query` Endpoint - Keyword Search
-
-**Via curl:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"find feedback about cannabis","top_k":5}'
-```
-
-**Expected Response:**
-- [ ] Status code: 200
-- [ ] Summary text (in English)
-- [ ] Has 5 results related to cannabis/search term
-- [ ] Each result has valid scores
-
----
-
-### 8. Test `/query` Endpoint - Hebrew Question
-
-**Via curl:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"מה הדעות הכלליות על השירות","top_k":5}'
-```
-
-**Expected Response:**
-- [ ] Status code: 200
-- [ ] Summary in Hebrew (response language matches query language)
-- [ ] Has 5 results with diverse feedback
-- [ ] Results ranked by relevance (scores in descending order)
-
----
-
-### 9. Test `/topics` Endpoint
-
-**Via curl:**
-```bash
-curl -X POST http://localhost:8000/topics \
-  -H "Content-Type: application/json" \
-  -d '{"num_topics":5}'
-```
-
-**Expected Response:**
-```json
-{
-  "topics": {
-    "0": ["word1", "word2", "word3", ...],
-    "1": ["word4", "word5", "word6", ...],
-    ...
-  },
-  "total_feedback": 9930
-}
-```
-
-- [ ] Status code: 200
-- [ ] Has 5 topics (0-4)
-- [ ] Each topic has top words
-- [ ] Total feedback count is 9930
-- [ ] Words are relevant to feedback content
-
----
-
-### 10. Test `/sentiment` Endpoint
-
-**Via curl:**
-```bash
-curl -X POST http://localhost:8000/sentiment \
-  -H "Content-Type: application/json" \
-  -d '{"limit":50}'
-```
-
-**Expected Response:**
-```json
-{
-  "count": 50,
-  "results": [
-    {
-      "text": "feedback text here",
-      "label": "POSITIVE",
-      "score": 0.95
-    },
-    ...
-  ]
-}
-```
-
-- [ ] Status code: 200
-- [ ] Count is 50
-- [ ] Has 50 results
-- [ ] Each result has: text, label (POSITIVE/NEGATIVE/NEUTRAL), score (0-1)
-- [ ] Labels are reasonable (positive feedback → POSITIVE, etc.)
-
----
-
-### 11. Test `/ingest` Endpoint (Optional - Rebuilds Index)
-
-**Via curl (takes 30-60 seconds):**
-```bash
-curl -X POST http://localhost:8000/ingest
-```
-
-**Expected Response:**
-```json
-{"status":"ok"}
-```
-
-- [ ] Status code: 200
-- [ ] Response `{"status":"ok"}`
-- [ ] Takes 30-60 seconds
-- [ ] Creates/overwrites `.vector_index/` files
-- [ ] After rebuild, query tests still work
-
-**Note:** This is for rebuilding the index after updating CSV. Only run if needed.
-
----
-
-## 🌐 Browser Testing (5 mins)
-
-### 12. Test Swagger UI
-
-**Open:** http://localhost:8000/docs
-
-- [ ] Page loads without errors
-- [ ] Swagger UI shows all 5 endpoints: health, query, topics, sentiment, ingest
-- [ ] Can expand each endpoint and see schema
-- [ ] Can enter test values and execute
-- [ ] Responses display correctly
-
-### 13. Test OpenAPI/ReDoc
-
-**Open:** http://localhost:8000/redoc
-
-- [ ] Page loads
-- [ ] All endpoints documented
-- [ ] Schema is clear
-
----
-
-## 🔍 Detailed Testing (Optional - 5 mins)
-
-### 14. Test Different Query Types in `/query`
-
-Test each query type to verify intent detection is working:
-
-**A) Count Thanks:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"thank you","top_k":2}'
-```
-- [ ] Detects as counting query
-- [ ] Returns count in summary
-
-**B) Count Problems:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"how many complaints","top_k":2}'
-```
-- [ ] Detects as complaint counting
-- [ ] Returns count
-
-**C) Keyword Search:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"slow","top_k":5}'
-```
-- [ ] Free-form search
-- [ ] Returns semantic matches
-
-**D) Hebrew Counting:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"כמה אנשים כתבו שהדברים עובדים","top_k":3}'
-```
-- [ ] Recognizes Hebrew counting query
-- [ ] Returns appropriate count
-
----
-
-### 15. Response Format Validation
-
-For each endpoint, verify:
-- [ ] Valid JSON format (no parsing errors)
-- [ ] All required fields present
-- [ ] Numeric fields are numbers (not strings)
-- [ ] Text fields are properly encoded (Hebrew text readable)
-- [ ] Timestamps accurate (if present)
-- [ ] No null/undefined values where data should exist
-
----
-
-## 📊 Performance Testing (10 mins)
-
-### 16. Measure Response Times
-
-**Health endpoint (should be <10ms):**
-```bash
-time curl -X POST http://localhost:8000/health
-```
-
-- [ ] Takes <10ms
-- [ ] Consistent across calls
-
-**Query endpoint (should be <3 seconds):**
-```bash
-time curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"test","top_k":5}'
-```
-
-- [ ] Takes 1-3 seconds (first call may be slower)
-- [ ] Subsequent calls faster
-- [ ] Consistent performance
-
-**Sentiment endpoint (depends on limit):**
-```bash
-time curl -X POST http://localhost:8000/sentiment \
-  -H "Content-Type: application/json" \
-  -d '{"limit":100}'
-```
-
-- [ ] Takes 5-15 seconds for 100 records
-- [ ] Scales reasonably with limit
-
----
-
-## 🐛 Error Handling (5 mins)
-
-### 17. Test Invalid Requests
-
-**Missing required fields:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{}'
-```
-
-- [ ] Status code: 422 (Unprocessable Entity)
-- [ ] Error message explains what's missing
-
-**Invalid JSON:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d 'not json'
-```
-
-- [ ] Status code: 422 or 400
-- [ ] Clear error response
-
-**Invalid top_k:**
-```bash
-curl -X POST http://localhost:8000/query \
-  -H "Content-Type: application/json" \
-  -d '{"query":"test","top_k":"not a number"}'
-```
-
-- [ ] Status code: 422
-- [ ] Error about type
-
----
-
-## ✨ Final Sign-Off
-
-All tests complete? Check off:
-
-- [ ] All 11 main endpoint tests pass
-- [ ] All response formats valid
-- [ ] Performance acceptable
-- [ ] Error handling works
-- [ ] No error logs in server terminal
-- [ ] Hebrew text renders correctly
-- [ ] Counts are accurate (1168 thanks, 352 complaints, 9930 total)
-
----
-
-## 📝 Test Results
-
-Record your results:
-
-**Date tested:** __________
-**Tester name:** __________
-**Python version:** __________
-**Environment:** ☐ Mac  ☐ Linux  ☐ Windows
-
-**Overall status:**
-- [ ] ✅ ALL TESTS PASSED - Ready for deployment
-- [ ] ⚠️  Some issues - See notes below
-
-**Notes:**
-```
-(Add any issues, observations, or special notes here)
-
-
-
-
-```
-
----
-
-## 🚀 Next Steps
-
-### If All Tests Pass ✅
-1. Stop the local server: `CTRL+C`
-2. Commit changes: `git add -A && git commit -m "test: all validation passed"`
-3. Push to GitHub: `git push origin main`
-4. Follow **README.md** to deploy to Runpod
-5. Test deployed version on cloud
-
-### If Some Tests Fail ⚠️
-1. Check the error message
-2. See QUICK_START.md **Troubleshooting** section
-3. Fix the issue
-4. Re-run `python3 scripts/validate_local.py`
-5. Retry failing endpoint test
-
----
-
-## 📚 Reference
-
-- **Full documentation:** See README.md
-- **Quick start guide:** See QUICK_START.md
-- **Configuration:** See app/config.py
-- **API definitions:** See app/api.py
-- **Deployment guide:** See CONTRIBUTING.md
-
-Good luck! 🎯
-

app/__init__.py

@@ -1,13 +1,18 @@
-"""Application package for the Feedback Analysis RAG Agent.
+"""
+Application package for the Feedback Analysis Agent.
 
-This package contains the core modules that implement ingestion, embedding,
-vector storage and the FastAPI endpoints used by the service.
+This package contains the core modules for SQL-based feedback analysis:
+- sql_service: Main analysis service using SQL queries
+- api: FastAPI endpoints
+- config: Configuration settings
+- data_loader: CSV data loading
 
 Import example:
-	from app.rag_service import RAGService
+	from app.sql_service import SQLFeedbackService
+	from app.api import app
 
 Keep this file minimal — module-level documentation only.
 """
 
-# Makes `app` a package so imports like `from app.rag_service import RAGService` work.
+# Makes `app` a package so imports work correctly
 

app/analysis.py

@@ -1,97 +0,0 @@
-from __future__ import annotations
-
-"""Utilities to detect simple question intents and resolve counts over the feedback corpus.
-
-This module implements lightweight, rule-based detection for queries such as:
-- "כמה משתמשים כתבו תודה" -> count thank-you messages
-- "כמה מתלוננים על אלמנטים שלא עובדים" -> count complaint-like messages
-
-The approach is intentionally simple (keyword matching) to avoid heavy dependencies and
-to provide fast, explainable counts. It returns structured dicts that higher-level code
-can convert to human-readable summaries or JSON responses.
-"""
-
-import re
-from typing import Iterable, List, Optional, Tuple
-
-import pandas as pd
-
-from .preprocess import preprocess_text
-from .config import settings
-
-
-COMPLAINT_KEYWORDS = [
-    "לא עובד",
-    "לא עובדים",
-    "שגיאה",
-    "תקלה",
-    "לא פועל",
-    "נכשל",
-    "לא מצליח",
-    "לא ניתן",
-    "המערכת לא",
-    "לא תקין",
-    "לא עובדים להם",
-]
-
-THANKS_KEYWORDS = ["תודה", "תודה רבה", "תודה!", "תודה רבה!", "תודה רבה מאוד"]
-
-
-def _contains_any(text: str, keywords: Iterable[str]) -> bool:
-    t = preprocess_text(text).lower()
-    for kw in keywords:
-        if kw in t:
-            return True
-    return False
-
-
-def count_keyword_rows(df: pd.DataFrame, keywords: Iterable[str], text_column: str = "Text") -> int:
-    if df is None or df.empty:
-        return 0
-    kws = [str(k).lower() for k in keywords]
-    def row_match(s: str) -> bool:
-        s = preprocess_text(str(s)).lower()
-        return any(kw in s for kw in kws)
-    return int(df[text_column].astype(str).apply(row_match).sum())
-
-
-def detect_query_type(query: str) -> Tuple[str, Optional[str]]:
-    """Return (type, target) where type is one of: 'count_thanks', 'count_complaint', 'count_keyword', 'freeform'.
-
-    target may contain a detected keyword or phrase when relevant.
-    """
-    q = preprocess_text(query).lower()
-    # Simple Hebrew heuristics
-    if "תודה" in q or "מודה" in q:
-        return ("count_thanks", None)
-    if any(k in q for k in ["לא עובד", "לא עובדים", "תקלה", "שגיאה", "לא פועל", "נכשל"]):
-        return ("count_complaint", None)
-    # Generic "כמה" count with a keyword after 'על' or 'ל' or 'בש"'
-    if q.strip().startswith("כמה") or "כמה משתמשים" in q:
-        # try extract noun after 'על' or 'ש' or 'עם'
-        m = re.search(r"על\s+([^\n\?]+)", q)
-        if m:
-            return ("count_keyword", m.group(1).strip())
-        m2 = re.search(r"כמה\s+[^\s]+\s+([^\n\?]+)", q)
-        if m2:
-            return ("count_keyword", m2.group(1).strip())
-        return ("count_keyword", None)
-    return ("freeform", None)
-
-
-def resolve_count_from_type(df: pd.DataFrame, qtype: str, target: Optional[str], text_column: str = "Text"):
-    if qtype == "count_thanks":
-        cnt = count_keyword_rows(df, THANKS_KEYWORDS, text_column=text_column)
-        return {"type": "count", "label": "thanks", "count": cnt}
-    if qtype == "count_complaint":
-        cnt = count_keyword_rows(df, COMPLAINT_KEYWORDS, text_column=text_column)
-        return {"type": "count", "label": "complaint_not_working", "count": cnt}
-    if qtype == "count_keyword":
-        if target:
-            # count rows that contain the exact target phrase
-            pattern = re.escape(target.lower())
-            cnt = int(df[text_column].astype(str).str.lower().str.contains(pattern, regex=True).sum())
-            return {"type": "count", "label": f"keyword:{target}", "count": int(cnt)}
-        # fallback: return total rows
-        return {"type": "count", "label": "all", "count": int(len(df))}
-    return {"type": "unknown"}

app/api.py

@@ -1,35 +1,34 @@
 from __future__ import annotations
 
 from typing import List, Optional, Dict, Any
+from pathlib import Path
+import json
 
-import numpy as np
-import pandas as pd
-from fastapi import FastAPI, Query, Request
+from fastapi import FastAPI
 from fastapi.responses import ORJSONResponse, HTMLResponse
 from fastapi.staticfiles import StaticFiles
-import json
-from pathlib import Path
 from pydantic import BaseModel, Field
 
 from .config import settings
 from .data_loader import load_feedback
-from .embedding import EmbeddingModel
-from .rag_service import RAGService
 from .sql_service import SQLFeedbackService
-from .sentiment import analyze_sentiments
-from .topics import kmeans_topics
-from .vector_store import FaissVectorStore
 
+# FastAPI application for Feedback Analysis using SQL-based approach
+app = FastAPI(
+    title="Feedback Analysis Agent", 
+    version="2.0.0", 
+    description="SQL-based feedback analysis system using LLM-generated queries",
+    default_response_class=ORJSONResponse
+)
 
-app = FastAPI(title="Feedback Analysis RAG Agent", version="1.0.0", default_response_class=ORJSONResponse)
-svc = RAGService()
 # Initialize SQL service lazily to avoid errors on startup if data is missing
-sql_svc = None
+# This service handles all query processing using SQL-based approach
+sql_svc: Optional[SQLFeedbackService] = None
 try:
-    sql_svc = SQLFeedbackService()  # SQL-based service
+    sql_svc = SQLFeedbackService()
+    print("SQL service initialized successfully", flush=True)
 except Exception as e:
     print(f"Warning: Could not initialize SQL service: {e}", flush=True)
-embedder = svc.embedder
 
 # Simple in-memory history persisted best-effort to `.query_history.json`
 history_file = Path(".query_history.json")
@@ -43,30 +42,59 @@ if history_file.exists():
 
 
 def save_history() -> None:
+    """
+    Save query history to disk.
+    
+    This is a best-effort operation - if saving fails (e.g., disk full,
+    permissions issue), the error is silently ignored to avoid breaking
+    the main application flow. History is stored in `.query_history.json`.
+    """
     try:
         with history_file.open("w", encoding="utf-8") as f:
             json.dump(history, f, ensure_ascii=False, indent=2)
     except Exception:
-        # best-effort persistence; ignore errors
+        # Best-effort persistence; ignore errors to avoid breaking main flow
         pass
 
 
 class QueryRequest(BaseModel):
+    """
+    Request model for query endpoints.
+    
+    Attributes:
+        query: The natural language question to analyze
+        top_k: Number of results to return (kept for compatibility, not actively used)
+    """
     query: str = Field(..., example="תסווג את התלונות 5 סוגים")
     top_k: int = Field(5, example=5)
 
 
 class QueryResponse(BaseModel):
+    """
+    Response model for legacy query endpoint (deprecated).
+    
+    Kept for backward compatibility but not actively used.
+    """
     query: str
     summary: Optional[str]
-    results: Optional[List[Dict[str, Any]]] = None  # Optional results for frontend
+    results: Optional[List[Dict[str, Any]]] = None
 
 
 class SQLQueryResponse(BaseModel):
+    """
+    Response model for SQL-based query endpoint.
+    
+    Attributes:
+        query: The original user query
+        summary: Final synthesized answer in natural language
+        sql_queries: List of SQL queries that were generated and executed
+        query_results: Results from each SQL query (as dictionaries for JSON serialization)
+        visualizations: Optional list of visualization specifications for frontend rendering
+    """
     query: str
     summary: str
     sql_queries: List[str]
-    query_results: List[Dict[str, Any]]  # Results of SQL queries
+    query_results: List[Dict[str, Any]]
     visualizations: Optional[List[Dict[str, Any]]] = None
 
 
@@ -106,15 +134,47 @@ def query_sql(req: QueryRequest) -> SQLQueryResponse:
         result = sql_svc.analyze_query(req.query)
         
         # Convert query results to JSON-serializable format
+        # Pandas DataFrames may contain numpy types that aren't JSON-serializable
+        # This helper function converts them to native Python types
+        def convert_to_python_type(val):
+            """
+            Convert numpy types to native Python types for JSON serialization.
+            
+            FastAPI/Pydantic can't serialize numpy types directly, so we need
+            to convert them. This function handles integers, floats, and arrays.
+            """
+            import numpy as np
+            if isinstance(val, (np.integer, np.int64, np.int32)):
+                return int(val)
+            elif isinstance(val, (np.floating, np.float64, np.float32)):
+                return float(val)
+            elif isinstance(val, np.ndarray):
+                return val.tolist()
+            return val
+        
         query_results = []
         for qr in result.query_results:
+            # Convert DataFrame to dict and clean numpy types
+            records = []
+            if not qr.error and len(qr.result) > 0:
+                for record in qr.result.to_dict('records'):
+                    cleaned_record = {k: convert_to_python_type(v) for k, v in record.items()}
+                    records.append(cleaned_record)
+            
             query_results.append({
                 "query": qr.query,
-                "result": qr.result.to_dict('records') if not qr.error else [],
+                "result": records,
                 "error": qr.error,
                 "row_count": len(qr.result) if not qr.error else 0
             })
         
+        # Save to history
+        try:
+            history.append({"query": result.user_query, "response": {"summary": result.summary}})
+            save_history()
+        except Exception:
+            pass
+        
         return SQLQueryResponse(
             query=result.user_query,
             summary=result.summary,
@@ -135,202 +195,6 @@ def query_sql(req: QueryRequest) -> SQLQueryResponse:
         )
 
 
-@app.post("/ingest")
-def ingest() -> Dict[str, Any]:
-    """Build the vector index from Feedback.csv"""
-    try:
-        svc.ingest()
-        return {"status": "ingested", "message": "Vector index built successfully"}
-    except FileNotFoundError as e:
-        return {"status": "error", "message": f"CSV file not found: {str(e)}"}
-    except Exception as e:
-        return {"status": "error", "message": f"Ingestion failed: {str(e)}"}
-
-
-@app.post("/query", response_model=QueryResponse)
-def query(req: QueryRequest, request: Request) -> QueryResponse:
-    """Free-form question answering over feedback data.
-
-    This endpoint also appends the (request, response) pair to an in-memory history
-    which is persisted best-effort to `.query_history.json`.
-    """
-    try:
-        # Use the higher-level answer pipeline which can handle counts and keyword queries
-        out = svc.answer(req.query, top_k=req.top_k)
-
-        # Return summary and also include results for frontend display if requested
-        # Convert numpy types to native Python types for JSON serialization
-        def convert_to_python_type(val):
-            import numpy as np
-            if isinstance(val, (np.integer, np.int64, np.int32)):
-                return int(val)
-            elif isinstance(val, (np.floating, np.float64, np.float32)):
-                return float(val)
-            elif isinstance(val, np.ndarray):
-                return val.tolist()
-            return val
-        
-        resp_dict = {
-            "query": out.query, 
-            "summary": out.summary,
-            "results": [
-                {
-                    "score": convert_to_python_type(r.score),
-                    "service": str(r.row.get(settings.service_column, "")),
-                    "level": convert_to_python_type(r.row.get(settings.level_column, "")),
-                    "text": str(r.row.get(settings.text_column, "")),
-                }
-                for r in out.results[:10]  # Limit to 10 for frontend
-            ] if out.results else []
-        }
-
-        # append to history (store only the summary)
-        try:
-            history.append({"query": out.query, "response": {"summary": out.summary}})
-            save_history()
-        except Exception:
-            pass
-
-        # Return QueryResponse with results
-        return QueryResponse(**resp_dict)
-    except FileNotFoundError:
-        resp = QueryResponse(
-            query=req.query,
-            summary="Error: Vector index not found. Please run /ingest first.",
-        )
-        try:
-            history.append({"query": resp.query, "response": {"summary": resp.summary}})
-            save_history()
-        except Exception:
-            pass
-        return resp
-    except Exception as e:
-        import traceback
-        error_details = traceback.format_exc()
-        print(f"Error in /query endpoint: {error_details}", flush=True)
-        resp = QueryResponse(
-            query=req.query,
-            summary=f"שגיאה: {str(e)}. אנא בדוק את הלוגים לפרטים נוספים.",
-            results=[]
-        )
-        try:
-            history.append({"query": resp.query, "response": {"summary": resp.summary}})
-            save_history()
-        except Exception:
-            pass
-        return resp
-
-
-class TopicsRequest(BaseModel):
-    num_topics: int = Field(5, example=5)
-
-
-@app.post("/topics")
-def topics(req: TopicsRequest) -> Dict[str, Any]:
-    """Extract main topics from feedback. Accepts POST body: {"num_topics": int}.
-
-    Using POST allows larger and structured request bodies (and avoids URL length limits).
-    """
-    num_topics = req.num_topics
-    try:
-        # Load embeddings from store
-        store = FaissVectorStore.load(settings.vector_index_path, settings.vector_metadata_path)
-        # FAISS does not expose vectors, so recompute for this endpoint
-        df = load_feedback()
-        texts = df[settings.text_column].astype(str).tolist()
-        if not texts:
-            return {"num_topics": 0, "topics": {}, "error": "No feedback data found"}
-        
-        embeddings = embedder.encode(texts)
-        res = kmeans_topics(embeddings, num_topics=num_topics)
-        
-        # Group texts by topic
-        topics_out: Dict[int, List[str]] = {}
-        for label, text in zip(res.labels, texts):
-            topics_out.setdefault(int(label), []).append(text)
-        
-        # Generate topic names/summaries using LLM if available
-        topic_summaries: Dict[int, str] = {}
-        for topic_id, topic_texts in topics_out.items():
-            # Take sample texts for summary
-            sample_texts = topic_texts[:10] if len(topic_texts) > 10 else topic_texts
-            sample_str = "\n".join(f"- {t[:200]}" for t in sample_texts[:5])
-            
-            prompt = (
-                "Based on the following citizen feedback examples, provide a short topic name (2-4 words) "
-                "in Hebrew that describes what users are talking about. "
-                "Return ONLY the topic name, nothing else.\n\n"
-                f"Examples:\n{sample_str}\n\nTopic name:"
-            )
-            
-            topic_name = f"נושא {topic_id + 1}"  # Default fallback
-            
-            # Try Gemini first
-            if settings.gemini_api_key:
-                try:
-                    import google.generativeai as genai
-                    genai.configure(api_key=settings.gemini_api_key)
-                    model = genai.GenerativeModel("gemini-1.5-flash")
-                    resp = model.generate_content(prompt)
-                    text = getattr(resp, "text", None)
-                    if isinstance(text, str) and text.strip():
-                        topic_name = text.strip()
-                except Exception:
-                    pass
-            
-            # Fallback to OpenAI
-            if topic_name.startswith("נושא") and settings.openai_api_key:
-                try:
-                    from openai import OpenAI
-                    client = OpenAI(api_key=settings.openai_api_key)
-                    resp = client.chat.completions.create(
-                        model="gpt-4o-mini",
-                        messages=[{"role": "user", "content": prompt}],
-                        temperature=0.3,
-                        max_tokens=20,
-                    )
-                    if resp.choices[0].message.content:
-                        topic_name = resp.choices[0].message.content.strip()
-                except Exception:
-                    pass
-            
-            topic_summaries[topic_id] = topic_name
-        
-        # Format response with topic names
-        formatted_topics: Dict[str, Any] = {}
-        for topic_id, topic_texts in topics_out.items():
-            formatted_topics[str(topic_id)] = {
-                "name": topic_summaries.get(topic_id, f"נושא {topic_id + 1}"),
-                "count": len(topic_texts),
-                "examples": topic_texts[:5]  # First 5 examples
-            }
-        
-        return {
-            "num_topics": num_topics,
-            "topics": formatted_topics,
-            "total_feedback": len(texts)
-        }
-    except FileNotFoundError:
-        return {"error": "Vector index not found. Please run /ingest first.", "num_topics": 0, "topics": {}}
-    except Exception as e:
-        return {"error": str(e), "num_topics": 0, "topics": {}}
-
-
-class SentimentRequest(BaseModel):
-    limit: int = Field(100, example=50)
-
-
-@app.post("/sentiment")
-def sentiment(req: SentimentRequest) -> Dict[str, Any]:
-    """Analyze sentiment for the first `limit` feedback entries. Accepts POST body: {"limit": 100}.
-
-    Using POST keeps the API consistent for clients that prefer JSON bodies over URL query params.
-    """
-    limit = req.limit
-    df = load_feedback().head(limit)
-    texts = df[settings.text_column].astype(str).tolist()
-    out = analyze_sentiments(texts)
-    return {"count": len(out), "results": out}
 
 
 # Mount static files for a simple frontend if present
@@ -352,13 +216,25 @@ def root() -> HTMLResponse:
 
 @app.get("/history")
 def get_history() -> Dict[str, Any]:
+    """
+    Get query history.
+    
+    Returns all previously asked questions and their responses.
+    History is persisted to `.query_history.json` and loaded on startup.
+    """
     return {"history": history}
 
 
 @app.post("/history/clear")
 def clear_history() -> Dict[str, Any]:
+    """
+    Clear query history.
+    
+    Removes all stored queries from memory and disk.
+    Useful for testing or privacy purposes.
+    """
     global history
     history = []
-    save_history()
+    save_history()  # Persist the cleared state to disk
     return {"status": "cleared"}
 

app/config.py

@@ -1,27 +1,42 @@
+"""
+Configuration settings for the Feedback Analysis system.
+
+This module loads environment variables and provides a centralized Settings class
+for all configuration values. Settings can be overridden via environment variables
+or a .env file (which is git-ignored for security).
+"""
+
 import os
 from dataclasses import dataclass
 from dotenv import load_dotenv  # type: ignore
 
 
-# Load .env if present (kept out of git via .gitignore)
+# Load .env file if present (kept out of git via .gitignore for security)
+# This allows local development without exposing API keys
 load_dotenv(override=False)
 
 
 @dataclass
 class Settings:
+    """
+    Application settings loaded from environment variables.
+    
+    All settings can be overridden via environment variables or .env file.
+    This provides flexibility for different deployment environments.
+    """
+    # LLM API keys - at least one must be set for the system to work
     openai_api_key: str | None = os.getenv("OPENAI_API_KEY")
     gemini_api_key: str | None = os.getenv("GEMINI_API_KEY")
-    embedding_model_name: str = os.getenv(
-        "EMBEDDING_MODEL",
-        "sentence-transformers/paraphrase-multilingual-mpnet-base-v2",
-    )
-    vector_index_path: str = os.getenv("VECTOR_INDEX_PATH", ".vector_index/faiss.index")
-    vector_metadata_path: str = os.getenv("VECTOR_METADATA_PATH", ".vector_index/meta.parquet")
+    
+    # CSV data file path - relative to project root
     csv_path: str = os.getenv("CSV_PATH", "Feedback.csv")
+    
+    # Column names in the CSV file - adjust if your CSV uses different column names
     text_column: str = os.getenv("TEXT_COLUMN", "Text")
     service_column: str = os.getenv("SERVICE_COLUMN", "ServiceName")
     level_column: str = os.getenv("LEVEL_COLUMN", "Level")
 
 
+# Global settings instance - import this in other modules
 settings = Settings()
 

app/embedding.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-"""EmbeddingModel wrapper around sentence-transformers.
-
-This class lazily loads a SentenceTransformer model (configured via
-`settings.embedding_model_name`) and exposes `encode` and `encode_single`.
-Normalizes embeddings to unit length for cosine-similarity search in FAISS.
-"""
-
-from typing import Iterable, List
-
-import numpy as np
-from sentence_transformers import SentenceTransformer  # type: ignore
-
-from .config import settings
-
-
-class EmbeddingModel:
-    def __init__(self, model_name: str | None = None) -> None:
-        self.model_name = model_name or settings.embedding_model_name
-        self.model = SentenceTransformer(self.model_name)
-
-    def encode(self, texts: Iterable[str], batch_size: int = 32) -> np.ndarray:
-        embeddings = self.model.encode(
-            list(texts),
-            batch_size=batch_size,
-            show_progress_bar=True,
-            convert_to_numpy=True,
-            normalize_embeddings=True,
-        )
-        return embeddings
-
-    def encode_single(self, text: str) -> np.ndarray:
-        return self.encode([text])[0]
-

app/preprocess.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-"""Text preprocessing helpers.
-
-Includes minimal normalization and an optional language detection helper. The
-`langdetect` dependency is optional — when it's not installed, `detect_language`
-returns "unknown". This keeps lightweight workflows (like simple counting) runnable
-without installing all NLP dependencies.
-"""
-
-try:
-    from langdetect import detect, DetectorFactory  # type: ignore
-    DetectorFactory.seed = 42
-
-    def detect_language(text: str) -> str:
-        try:
-            return detect(text)
-        except Exception:
-            return "unknown"
-except Exception:
-    # langdetect is optional for lightweight usage; provide fallback
-    def detect_language(text: str) -> str:
-        return "unknown"
-
-
-def normalize_text(text: str) -> str:
-    # Minimal normalization; keep non-latin scripts (Hebrew)
-    return " ".join(str(text).split())
-
-
-def preprocess_text(text: str) -> str:
-    return normalize_text(text)
-

app/rag_service.py

@@ -1,1057 +0,0 @@
-from __future__ import annotations
-
-import argparse
-from dataclasses import dataclass
-from typing import List, Optional, Dict
-
-import numpy as np
-import pandas as pd
-
-from .config import settings
-from .data_loader import load_feedback
-from .embedding import EmbeddingModel
-from .preprocess import preprocess_text
-from .vector_store import FaissVectorStore, SearchResult
-from .analysis import detect_query_type, resolve_count_from_type
-
-
-try:
-    from openai import OpenAI  # type: ignore
-except Exception:  # pragma: no cover - optional
-    OpenAI = None  # type: ignore
-
-try:
-    import google.generativeai as genai  # type: ignore
-except Exception:  # pragma: no cover - optional
-    genai = None  # type: ignore
-
-
-@dataclass
-class RetrievalOutput:
-    query: str
-    results: List[SearchResult]
-    summary: Optional[str]
-
-
-class RAGService:
-    def __init__(self) -> None:
-        self.embedder = EmbeddingModel()
-        self.store: Optional[FaissVectorStore] = None
-
-    def ingest(self, df: Optional[pd.DataFrame] = None) -> None:
-        data = df if df is not None else load_feedback()
-        texts = [preprocess_text(t) for t in data[settings.text_column].astype(str).tolist()]
-        vectors = self.embedder.encode(texts)
-
-        store = FaissVectorStore(dim=vectors.shape[1])
-        store.add(vectors.astype(np.float32), data[[settings.text_column, settings.service_column, settings.level_column]])
-        store.save(settings.vector_index_path, settings.vector_metadata_path)
-        self.store = store
-
-    def _ensure_store(self) -> None:
-        if self.store is None:
-            import os
-            if not os.path.exists(settings.vector_index_path):
-                raise FileNotFoundError(
-                    f"Vector index not found at {settings.vector_index_path}. "
-                    "Please run /ingest endpoint first or precompute the index."
-                )
-            self.store = FaissVectorStore.load(settings.vector_index_path, settings.vector_metadata_path)
-
-    def retrieve(self, query: str, top_k: int = 5, level_filter: Optional[tuple] = None) -> List[SearchResult]:
-        """Retrieve results with optional level filtering.
-        
-        Args:
-            query: Search query
-            top_k: Number of results to retrieve
-            level_filter: Optional tuple (min_level, max_level) to filter by level
-        """
-        self._ensure_store()
-        assert self.store is not None
-        q_vec = self.embedder.encode_single(preprocess_text(query))
-        
-        # Retrieve more results if filtering is needed (to ensure we get enough after filtering)
-        search_k = top_k * 3 if level_filter else top_k
-        results = self.store.search(q_vec, top_k=search_k)
-        
-        # Apply level filter if specified
-        if level_filter:
-            min_level, max_level = level_filter
-            filtered_results = []
-            for r in results:
-                level = r.row.get(settings.level_column)
-                if level is not None:
-                    try:
-                        level_val = float(level)
-                        if min_level <= level_val <= max_level:
-                            filtered_results.append(r)
-                            if len(filtered_results) >= top_k:
-                                break
-                    except (ValueError, TypeError):
-                        continue
-            return filtered_results
-        
-        return results[:top_k]
-
-    def summarize(self, query: str, contexts: List[str]) -> Optional[str]:
-        if not contexts:
-            return None
-        joined = "\n".join(f"- {c}" for c in contexts[:10])
-        # Detect if query is in Hebrew
-        is_hebrew = any('\u0590' <= char <= '\u05FF' for char in query)
-        lang_instruction = "ענה בעברית" if is_hebrew else "Answer in the language of the query"
-        
-        prompt = (
-            f"You are a government digital services assistant. Based on the following citizen feedback snippets, "
-            f"write a concise summary (max 100 words) highlighting key issues and suggestions. "
-            f"{lang_instruction}.\n\n"
-            f"Query:\n{query}\n\nFeedback:\n{joined}\n\nSummary:"
-        )
-        # Prefer Gemini if configured
-        if settings.gemini_api_key and genai is not None:
-            try:
-                genai.configure(api_key=settings.gemini_api_key)
-                model = genai.GenerativeModel("gemini-1.5-flash")
-                resp = model.generate_content(prompt)
-                text = getattr(resp, "text", None)
-                if isinstance(text, str) and text.strip():
-                    return text.strip()
-            except Exception:
-                pass
-        # Fallback to OpenAI if available
-        if settings.openai_api_key and OpenAI is not None:
-            client = OpenAI(api_key=settings.openai_api_key)
-            try:
-                resp = client.chat.completions.create(
-                    model="gpt-4o-mini",
-                    messages=[{"role": "user", "content": prompt}],
-                    temperature=0.2,
-                    max_tokens=200,
-                )
-                return resp.choices[0].message.content
-            except Exception:
-                pass
-        # Fallback: simple extractive "summary"
-        return " ".join(contexts[:3])
-
-    def _validate_and_fix_response(self, response: str, query: str, aggregates_str: str) -> str:
-        """Validate response and fix if needed. Returns validated/fixed response."""
-        if not response or len(response.strip()) < 50:
-            return "לא הצלחתי ליצור תשובה מספקת מהנתונים. אנא נסה שאילתה אחרת או בדוק שהאינדקס נבנה כראוי."
-        
-        # Check for obvious nonsense patterns
-        nonsense_patterns = [
-            "אני לא יכול", "I cannot", "I don't know", "לא יודע",
-            "לא ניתן", "cannot provide", "unable to", "אני לא",
-            "I'm sorry", "I apologize", "סליחה", "לא מצאתי"
-        ]
-        if any(pattern in response.lower() for pattern in [p.lower() for p in nonsense_patterns]):
-            # Try to fix by asking the model to be more specific
-            return self._request_fix(response, query, aggregates_str)
-        
-        # Check if response is too short (relaxed threshold - allow shorter responses if they're good)
-        word_count = len(response.split())
-        if word_count < 400:
-            # Response is very short, try to get more detail (target is 600-800 words)
-            return self._request_fix(response, query, aggregates_str)
-        
-        # Check if response is just a jumble of words (no clear structure, no sentences, just words)
-        # Count sentences (periods, exclamation marks, question marks)
-        sentence_count = response.count('.') + response.count('!') + response.count('?')
-        if sentence_count < 10 and word_count > 200:
-            # Response has many words but few sentences - might be a jumble
-            # Check if there are enough paragraphs (double newlines or line breaks)
-            paragraph_count = response.count('\n\n') + response.count('\r\n\r\n')
-            if paragraph_count < 3:
-                # Response seems like a jumble - not enough structure
-                return self._request_fix(response, query, aggregates_str)
-        
-        # Check if response seems too generic or just a list of examples (doesn't contain analysis)
-        has_numbers = any(char.isdigit() for char in response)
-        has_analysis_terms = any(term in response for term in [
-            "משוב", "משתמש", "שירות", "דירוג", "נתונים", "ניתוח", "מגמה", "דפוס", 
-            "השוואה", "אחוז", "ממוצע", "feedback", "user", "service", "analysis", "pattern", "trend"
-        ])
-        
-        # Check for business understanding terms
-        has_business_terms = any(term in response for term in [
-            "משמעות", "השפעה", "סיכון", "הזדמנות", "המלצה", "צעד", "תיקון", "שיפור",
-            "מגמה", "דפוס", "נושא", "בעיה", "פתרון", "impact", "risk", "opportunity",
-            "recommendation", "action", "improvement", "trend", "pattern", "issue", "solution"
-        ])
-        
-        # Check if response is just listing examples (too many bullet points or numbers)
-        bullet_points = response.count("•") + response.count("-") + response.count("1.") + response.count("2.") + response.count("3.") + response.count("4.") + response.count("5.")
-        is_mostly_list = bullet_points > word_count / 15  # More than ~6.5% of content is list markers
-        
-        # Check if response is just a list of short phrases (common pattern: each line is a short phrase)
-        lines = [line.strip() for line in response.split("\n") if line.strip()]
-        short_lines = sum(1 for line in lines if len(line.split()) < 8)  # Lines with less than 8 words
-        is_list_of_phrases = len(lines) > 3 and short_lines > len(lines) * 0.7  # More than 70% are short lines
-        
-        # Check if response lacks coherent structure (too many short sentences, not enough paragraphs)
-        sentences = response.count(".") + response.count("!") + response.count("?")
-        avg_sentence_length = word_count / max(sentences, 1)
-        is_fragmented = avg_sentence_length < 12 and word_count > 100  # Too many very short sentences
-        
-        # Check if response has enough paragraphs (should have at least 3-4 paragraphs for a good analysis)
-        paragraphs = [p.strip() for p in response.split("\n\n") if p.strip()]
-        has_enough_paragraphs = len(paragraphs) >= 3
-        
-        # Check if query is about feelings/opinions and response should cover both sides
-        is_feelings_query = any(term in query.lower() for term in [
-            "מרגיש", "רגש", "דעה", "אוהב", "שונא", "מרוצה", "לא מרוצ��", 
-            "feel", "opinion", "like", "dislike", "satisfied", "unsatisfied"
-        ])
-        
-        if is_feelings_query:
-            # Check if response covers both positive and negative sides
-            has_positive_terms = any(term in response for term in [
-                "מרוצה", "אוהב", "חיובי", "טוב", "מעולה", "מצוין", "דירוג גבוה", "דירוג 4", "דירוג 5",
-                "satisfied", "positive", "good", "excellent", "high rating", "rating 4", "rating 5"
-            ])
-            has_negative_terms = any(term in response for term in [
-                "לא מרוצה", "שונא", "שלילי", "רע", "גרוע", "דירוג נמוך", "דירוג 1", "דירוג 2",
-                "unsatisfied", "negative", "bad", "poor", "low rating", "rating 1", "rating 2"
-            ])
-            if not (has_positive_terms and has_negative_terms) and word_count < 500:
-                # Response doesn't cover both sides and is short, try to improve
-                return self._request_fix(response, query, aggregates_str)
-        
-        # Relaxed validation - only fix if really problematic (target is 600-800 words)
-        if (not has_numbers or not has_analysis_terms) and word_count < 400:
-            # Response seems too generic or lacks analysis, try to improve
-            return self._request_fix(response, query, aggregates_str)
-        
-        if is_mostly_list and word_count < 400:
-            # Response is mostly a list and very short, try to improve
-            return self._request_fix(response, query, aggregates_str)
-        
-        if not has_business_terms and word_count < 500:
-            # Response lacks business understanding and is short, try to improve
-            return self._request_fix(response, query, aggregates_str)
-        
-        if is_fragmented and word_count < 400:
-            # Response is too fragmented and short, try to improve
-            return self._request_fix(response, query, aggregates_str)
-        
-        if not has_enough_paragraphs and word_count < 400:
-            # Response doesn't have enough structure and is short, try to improve
-            return self._request_fix(response, query, aggregates_str)
-        
-        # Check for repetitive or nonsensical patterns (same word repeated many times)
-        words = response.split()
-        if len(words) > 0:
-            word_freq = {}
-            for word in words:
-                word_freq[word] = word_freq.get(word, 0) + 1
-            max_repetition = max(word_freq.values()) if word_freq else 0
-            if max_repetition > len(words) * 0.2:  # If any word appears more than 20% of the time
-                # Response seems repetitive/nonsensical
-                return self._request_fix(response, query, aggregates_str)
-        
-        return response
-    
-    def _request_fix(self, original_response: str, query: str, aggregates_str: str) -> str:
-        """Ask the LLM to fix/improve a response that failed validation."""
-        # Check if query is about feelings/opinions
-        is_feelings_query = any(term in query.lower() for term in [
-            "מרגיש", "רגש", "דעה", "אוהב", "שונא", "מרוצה", "לא מרוצה", 
-            "feel", "opinion", "like", "dislike", "satisfied", "unsatisfied"
-        ])
-        
-        feelings_instruction = ""
-        if is_feelings_query:
-            feelings_instruction = (
-                f"\nחשוב מאוד - השאלה מתייחסת לרגשות/תחושות/דעות. פורמט ספציפי:\n"
-                f"1. התחל עם סיכום כללי קצר (2-3 משפטים) שמתאר את התמונה הגדולה:\n"
-                f"   - דוגמה: 'נראה שיש רגשות מעורבים כלפי השירות' או 'רוב המשתמשים מרוצים מהשירות'\n"
-                f"   - כלול מספרים: כמה משתמשים מרוצים? כמה לא? מה האחוזים?\n"
-                f"2. המשך עם ניתוח של המשתמשים המרוצים (דירוג 4-5):\n"
-                f"   - מה הם אומרים? מה הם אוהבים? מה עובד טוב?\n"
-                f"   - כלול דוגמאות קונקרטיות מהמשובים - צטט או תאר משובים ספציפיים\n"
-                f"   - דוגמה: 'רוב המשתמשים מרוצים ומודים על השירות, כפי שניתן לראות במשובים כמו...'\n"
-                f"3. המשך עם ניתוח של המשתמשים הלא מרוצים (דירוג 1-2):\n"
-                f"   - מה הם אומרים? מה הם לא אוהבים? מה לא עובד?\n"
-                f"   - כלול בעיות ספציפיות עם דוגמאות קונקרטיות מהמשובים\n"
-                f"   - דוגמה: 'חלק מהמשתמשים מצביעים על בעיות משמעותיות כמו שדות שלא ניתן לערוך אותם, חוסר ידיעה שמונעת מהם להזין שדות אחרים, או ציפייה (ותסכול) על אי קבלת מסמכים בדואר'\n"
-                f"   - צטט או תאר משובים ספציפיים שמדגימים את הבעיות\n"
-                f"4. סיים עם סיכום והמלצות\n"
-            )
-        
-        fix_prompt = (
-            f"התשובה הבאה לא מספקת - היא קצרה מדי, לא קוהרנטית, גיבוב של מילים, או חסר מבנה ברור. אנא כתוב תשובה חדשה ומתוקנת:\n\n"
-            f"חשוב מאוד - אגרגציה חכמה (קריטי!):\n"
-            f"1. קודם כל, עשה אגרגציה חכמה של כל הנתונים:\n"
-            f"   - קרא ונתח את כל הסטטיסטיקות והסיכומים שסופקו\n"
-            f"   - זהה את הדפוסים והנושאים המרכזיים שחוזרים על עצמם\n"
-            f"   - הבן את התמונה הגדולה - מה המגמות הכלליות? מה הנושאים הדומיננטיים?\n"
-            f"   - השווה בין קבוצות שונות (מרוצים vs לא מרוצים, שירותים שונים)\n"
-            f"\n"
-            f"2. רק אחרי שעשית אגרגציה חכמה - כתוב תשובה מסכמת ברורה ומסודרת:\n"
-            f"   - תשובה שמסכמת את הממצאים העיקריים מהאגרגציה\n"
-            f"   - תשובה שמראה הבנה עמוקה של הדפוסים והנושאים המרכזיים\n"
-            f"   - תשובה שמבוססת על ניתוח מעמיק, לא רק חיבור של משובים בודדים\n"
-            f"   - תשובה ברורה ומסודרת - לא גיבוב של מילים\n"
-            f"   - אל תכתוב: 'משתמש אחד אמר X, משתמש שני אמר Y'\n"
-            f"   - במקום זה, כתוב: 'נראה שיש דפוס ברור של X בקרב Y% מהמשתמשים'\n"
-            f"\n"
-            f"מבנה התשובה - חובה (קריטי!):\n"
-            f"התשובה חייבת להיות מסודרת בבירור עם מבנה ברור:\n"
-            f"1. פתיחה - סיכום מנהלים (פסקה אחת, 3-4 משפטים): סיכום כללי של התמונה הגדולה עם מספרים\n"
-            f"2. ניתוח מפורט לפי נושאים/דעות (3-5 פסקאות, כל פסקה 4-6 משפטים): כל פסקה בנושא/דעה מרכזי אחד\n"
-            f"3. השוואות וניתוח מעמיק (2-3 פסקאות): השוואות בין קבוצות ושירותים\n"
-            f"4. תובנות עסקיות והמלצות (2-3 פסקאות): משמעות, השפעה, המלצות\n"
-            f"5. סיכום (פסקה אחת, 2-3 משפטים): מסקנות עיקריות ונקודות מפתח\n"
-            f"\n"
-            f"דרישות לתשובה המתוקנת (חובה!):\n"
-            f"1. תשובה קוהרנטית, מפורטת מאוד ומקיפה בפסקאות מלאות (לפחות 7-10 פסקאות, לפחות 600-800 מילים)\n"
-            f"2. תשובה ברורה ומסודרת - לא גיבוב של מילים, אלא מבנה ברור עם סעיפים ופסקאות\n"
-            f"3. כל פסקה צריכה להיות קוהרנטית וממוקדת בנושא אחד (4-6 משפטים ארוכים ומפורטים)\n"
-            f"4. תשובה שמראה הבנה רחבה ומקיפה של כל הנתונים - לא רק רשימת משובים בודדים\n"
-            f"5. תשובה שכוללת כמה דעות/נושאים מרכזיים (לא רק נושא אחד)\n"
-            f"6. הרחב על כל נקודה - תן הסברים מפורטים, דוגמאות מרובות, והשוואות מעמיקות\n"
-            f"7. תשובה שמסכמת את הממצאים העיקריים מהאגרגציה החכמה - לא רק חיבור של משובים\n"
-            f"{feelings_instruction}"
-            f"8. מבוססת אך ורק על הנתונים הסטטיסטיים הבאים:\n{aggregates_str}\n"
-            f"9. עונה ישירות על השאלה: {query}\n"
-            f"10. כוללת מספרים מדויקים מהנתונים (כמה משתמשים, אחוזים, ממוצעים, וכו')\n"
-            f"11. מראה הבנה של דפוסים ונושאים מרכזיים - לא רק דוגמאות בודדות\n"
-            f"12. תשובה קוהרנטית ומקצועית - ניתוח מעמיק, לא רק חיבור של משובים\n"
-            f"13. כוללת תובנות עסקיות מעמיקות והמלצות מעשיות\n"
-            f"14. הגיונית, לוגית, וקשורה לשאלה - לא שטויות או גיבוב מילים\n"
-            f"15. כתובה בעברית מקצועית וקולחת\n\n"
-            f"התשובה המקורית (לא מספקת - אל תשתמש בה, רק כתוב תשובה חדשה):\n{original_response}\n\n"
-            f"אנא כתוב תשובה חדשה ומתוקנת שעומדת בכל הדרישות לעיל - תשובה קוהרנטית ומקיפה בפסקאות מלאות שמראה הבנה של כל הנתונים:"
-        )
-        
-        # Try Gemini first
-        if settings.gemini_api_key and genai is not None:
-            try:
-                genai.configure(api_key=settings.gemini_api_key)
-                model = genai.GenerativeModel("gemini-1.5-flash")
-                generation_config = {
-                    "temperature": 0.7,  # Moderate temperature for fixes - still creative but focused
-                    "top_p": 0.95,
-                    "top_k": 40,
-                    "max_output_tokens": 3000,
-                }
-                resp = model.generate_content(fix_prompt, generation_config=generation_config)
-                text = getattr(resp, "text", None)
-                if isinstance(text, str) and text.strip() and len(text.strip()) > 100:
-                    return text.strip()
-            except Exception:
-                pass
-        
-        # Fallback to OpenAI
-        if settings.openai_api_key and OpenAI is not None:
-            try:
-                client = OpenAI(api_key=settings.openai_api_key)
-                resp = client.chat.completions.create(
-                    model="gpt-4o-mini",
-                    messages=[{"role": "user", "content": fix_prompt}],
-                    temperature=0.7,
-                    max_tokens=2500,
-                )
-                fixed = resp.choices[0].message.content
-                if fixed and len(fixed.strip()) > 100:
-                    return fixed.strip()
-            except Exception:
-                pass
-        
-        # If fix failed, return original with note
-        return f"{original_response}\n\n[הערה: התשובה עשויה להיות לא מלאה. אנא נסה שאילתה יותר ספציפית.]"
-
-    def synthesize(self, query: str, results: List[SearchResult], contexts: List[str], max_contexts: int = 100, level_filter: Optional[tuple] = None) -> Optional[str]:
-        """Produce a free-form, analyst-style answer that synthesizes the retrieved contexts.
-
-        This method asks the LLM to act as an experienced data analyst for digital business
-        processes and to synthesize insights, root causes, business impact and recommended
-        next steps. It is explicitly not an extractive response of "most relevant" snippets.
-        """
-        if not contexts:
-            return None
-
-        # Load full dataset for comprehensive analysis
-        try:
-            df = load_feedback()
-            # Apply level filter to dataset if specified
-            if level_filter:
-                min_level, max_level = level_filter
-                df = df[(df[settings.level_column] >= min_level) & (df[settings.level_column] <= max_level)].copy()
-            total_records = len(df)
-        except Exception:
-            df = None
-            total_records = 0
-        
-        # Instead of showing individual examples, create comprehensive summaries
-        # Group by service and level to show patterns
-        if df is not None and len(df) > 0:
-            # Create service-level summaries
-            service_summaries = []
-            for service_name in df[settings.service_column].unique()[:20]:  # Top 20 services
-                service_df = df[df[settings.service_column] == service_name]
-                if len(service_df) > 0:
-                    avg_level = service_df[settings.level_column].mean()
-                    count = len(service_df)
-                    high_ratings = len(service_df[service_df[settings.level_column] >= 4])
-                    low_ratings = len(service_df[service_df[settings.level_column] <= 2])
-                    # Sample a few representative texts
-                    sample_texts = service_df[settings.text_column].head(3).tolist()
-                    service_summaries.append(
-                        f"שירות: {service_name}\n"
-                        f"  - מספר משובים: {count}\n"
-                        f"  - ממוצע דירוג: {avg_level:.2f}\n"
-                        f"  - דירוגים גבוהים (4-5): {high_ratings} ({(high_ratings/count*100):.1f}%)\n"
-                        f"  - דירוגים נמוכים (1-2): {low_ratings} ({(low_ratings/count*100):.1f}%)\n"
-                        f"  - דוגמאות: {', '.join([t[:100] + '...' if len(t) > 100 else t for t in sample_texts])}"
-                    )
-            
-            # Create level-based summaries
-            level_summaries = []
-            for level in sorted(df[settings.level_column].unique()):
-                level_df = df[df[settings.level_column] == level]
-                if len(level_df) > 0:
-                    count = len(level_df)
-                    percentage = (count / total_records * 100)
-                    # Sample representative texts
-                    sample_texts = level_df[settings.text_column].head(5).tolist()
-                    level_summaries.append(
-                        f"דירוג {level} ({count} משובים, {percentage:.1f}%):\n"
-                        f"  דוגמאות: {' | '.join([t[:80] + '...' if len(t) > 80 else t for t in sample_texts[:3]])}"
-                    )
-            
-            # Include top retrieved examples for context (but not all)
-            top_examples = []
-            for i, r in enumerate(results[:50]):  # Top 50 most relevant
-                text = r.row.get(settings.text_column, "")
-                service = r.row.get(settings.service_column, "")
-                level = r.row.get(settings.level_column, "")
-                score = r.score
-                top_examples.append(f"[דמיון: {score:.3f}, שירות: {service}, דירוג: {level}] {text[:150]}{'...' if len(text) > 150 else ''}")
-            
-            joined = (
-                f"סיכום מקיף של כל הנתונים ({total_records} משובים בסך הכל):\n\n"
-                f"סיכום לפי שירותים (20 השירותים המובילים):\n" + "\n\n".join(service_summaries) + "\n\n"
-                f"סיכום לפי דירוגים:\n" + "\n\n".join(level_summaries) + "\n\n"
-                f"דוגמאות רלוונטיות ביותר (50 המשובים הרלוונטיים ביותר לשאילתה):\n" + "\n".join(f"{i+1}. {ex}" for i, ex in enumerate(top_examples))
-            )
-        else:
-            # Fallback to original method if dataset loading fails
-            safe_ctxs = []
-            for i, r in enumerate(results[:max_contexts]):
-                text = r.row.get(settings.text_column, "")
-                service = r.row.get(settings.service_column, "")
-                level = r.row.get(settings.level_column, "")
-                ctx = f"[שירות: {service}, דירוג: {level}] {text}"
-                if len(ctx) > 400:
-                    ctx = ctx[:400] + "..."
-                safe_ctxs.append(ctx)
-            joined = "\n\n".join(f"{i+1}. {c}" for i, c in enumerate(safe_ctxs))
-
-        # Detect if query is in Hebrew
-        is_hebrew = any('\u0590' <= char <= '\u05FF' for char in query)
-        lang_instruction = "ענה בעברית באופן מקצועי" if is_hebrew else "Answer in the language of the query in a professional tone"
-
-        instruction = (
-            "אתה אנליסט נתונים בכיר ומנוסה, מומחה בניתוח משובי משתמשים על שירותים דיגיטליים.\n"
-            "יש לך גישה מלאה לכל הנתונים - אתה רואה את התמונה הגדולה של כל המשובים.\n"
-            "\n"
-            "מבנה הנתונים:\n"
-            "- Text: הטקסט המלא של המשוב\n"
-            "- Level: הדירוג (1-5, 5=הטוב ביותר, 1=הגרוע ביותר)\n"
-            "- ServiceName: שם השירות\n"
-            "\n"
-            "חשוב מאוד - איך לעבוד (קריטי!):\n"
-            "1. קודם כל, עשה אגרגציה חכמה של כל הנתונים:\n"
-            "   - קרא ונתח את כל הסטטיסטיקות והסיכומים שסופקו\n"
-            "   - זהה את הדפוסים והנושאים המרכזיים שחוזרים על עצמם\n"
-            "   - הבן את התמונה הגדולה - מה המגמות הכלליות? מה הנושאים הדומיננטיים?\n"
-            "   - השווה בין קבוצות שונות (מרוצים vs לא מרוצים, שירותים שונים)\n"
-            "   - זהה קשרים והקשרים בין נושאים שונים\n"
-            "   - הבן את המשמעות העסקית - מה זה אומר בפועל?\n"
-            "\n"
-            "2. אחרי האגרגציה החכמה - כתוב תשובה ברורה ומסודרת:\n"
-            "   - תשובה שמסכמת את הממצאים העיקריים מהאגרגציה\n"
-            "   - תשובה שמראה הבנה עמוקה של הדפוסים והנושאים המרכזיים\n"
-            "   - תשובה שמבוססת על ניתוח מעמיק, לא רק חיבור של משובים בודדים\n"
-            "   - תשובה ברורה ומסודרת - לא גיבוב של מילים\n"
-            "\n"
-            "3. מה זה אומר בפועל:\n"
-            "   - אל תכתוב: 'משתמש אחד אמר X, משתמש שני אמר Y, משתמש שלישי אמר Z'\n"
-            "   - במקום זה, כתוב: 'נראה שיש דפוס ברור של X בקרב Y% מהמשתמשים, בעוד ש-Z% מציינים Y'\n"
-            "   - זהה נושאים מרכזיים שחוזרים על עצמם והסבר אותם בצורה ברורה\n"
-            "   - השווה בין קבוצות שונות והסבר את ההבדלים\n"
-            "   - תן תובנות עסקיות שמבוססות על הבנה של כל הנתונים יחד\n"
-            "\n"
-            "כללים חשובים:\n"
-            "1. תשובותיך מבוססות רק על הנתונים שסופקו - אל תמציא\n"
-            "2. תן תשובה קוהרנטית ומקיפה שמראה הבנה של כל הנתונים\n"
-            "3. כל מספר חייב להיות מדויק מהנתונים\n"
-            "4. תשובה מפורטת מאוד וארוכה (7-10 פסקאות, 600-800 מילים לפחות)\n"
-            "5. תשובה ברורה ומסודרת - לא גיבוב של מילים\n"
-            "\n"
-            "מבנה התשובה - חובה (קריטי!):\n"
-            "התשובה חייבת להיות מסודרת בבירור עם סעיפים ופסקאות:\n"
-            "\n"
-            "1. פתיחה - סיכום מנהלים (פסקה אחת, 3-4 משפטים):\n"
-            "   - תן סיכום כללי קצר של התמונה הגדולה\n"
-            "   - מה המגמות הכלליות? מה המסקנות העיקריות?\n"
-            "   - כלול מספרים מדויקים (כמה משתמשים מרוצים? כמה לא? אחוזים?)\n"
-            "\n"
-            "2. ניתוח מפורט לפי נושאים/דעות (3-5 פסקאות, כל פסקה 4-6 משפטים):\n"
-            "   - כל פסקה תעסוק בנושא/דעה מרכזי אחד\n"
-            "   - זהה את הנושאים המרכזיים מהאגרגציה והסבר כל אחד מהם\n"
-            "   - כלול מספרים מדויקים, אחוזים, והשוואות\n"
-            "   - כלול דוגמאות קונקרטיות מהמשובים (2-3 דוגמאות לכל נושא)\n"
-            "   - הסבר את המשמעות העסקית של כל נושא\n"
-            "\n"
-            "3. השוואות וניתוח מעמיק (2-3 פסקאות, כל פסקה 4-6 משפטים):\n"
-            "   - השווה בין קבוצות שונות (מרוצים vs לא מרוצים)\n"
-            "   - השווה בין שירותים שונים\n"
-            "   - זהה קשרים והקשרים - מה גורם למה?\n"
-            "   - הסבר את ההבדלים והמשמעות שלהם\n"
-            "\n"
-            "4. תובנות עסקיות והמלצות (2-3 פסקאות, כל פסקה 4-6 משפטים):\n"
-            "   - מה המשמעות העסקית של הממצאים?\n"
-            "   - מה ההשפעה על השירות?\n"
-            "   - מה הסיכונים וההזדמנויות?\n"
-            "   - המלצות מעשיות וקונקרטיות - מה צריך לעשות?\n"
-            "\n"
-            "5. סיכום (פסקה אחת, 2-3 משפטים):\n"
-            "   - סיכום קצר של המסקנות העיקריות\n"
-            "   - נקודות מפתח לפעולה\n"
-            "\n"
-            "כללי כתיבה:\n"
-            "- כתוב בצורה ברורה ומסודרת - לא גיבוב של מילים\n"
-            "- כל פסקה צריכה להיות קוהרנטית וממוקדת בנושא אחד\n"
-            "- השתמש במעברים ברורים בין פסקאות\n"
-            "- כלול מספרים מדויקים, אחוזים, והשוואות\n"
-            "- כלול דוגמאות קונקרטיות מהמשובים\n"
-            "- כתוב בצורה טבעית וקולחת - כאילו אתה מסביר למנהל\n"
-            "- תן תשובה ארוכה ומקיפה - לפחות 600-800 מילים, 7-10 פסקאות\n"
-            "- הרחב על כל נקודה - תן הסברים מפורטים, דוגמאות מרובות, והשוואות מעמיקות\n"
-            "- תשובה שמסכמת את הממצאים העיקריים מהאגרגציה החכמה שעשית\n"
-            "\n"
-            "בדיקה אחרונה לפני שליחת התשובה - חובה לבדוק:\n"
-            "1. האם התשובה ברורה ומסודרת עם מבנה ברור (פתיחה, ניתוח לפי נושאים, השוואות, תובנות, סיכום)?\n"
-            "2. האם התשובה לא גיבוב של מילים אלא תשובה קוהרנטית ומסודרת?\n"
-            "3. האם עשית אגרגציה חכמה של כל הנתונים לפני כתיבת התשובה?\n"
-            "4. האם התשובה מסכמת את הממצאים העיקריים מהאגרגציה (לא רק חיבור של משובים בודדים)?\n"
-            "5. האם התשובה מראה הבנה עמוקה של הדפוסים והנושאים המרכזיים?\n"
-            "6. האם התשובה ארוכה ומקיפה מספיק (לפחות 600-800 מילים, 7-10 פסקאות)?\n"
-            "7. האם התשובה כוללת כמה דעות/נושאים מרכזיים (לא רק נושא אחד)?\n"
-            "8. אם השאלה מתייחסת לרגשות/תחושות/דעות - האם התשובה כוללת ניתוח של שני הצדדים (מרוצים ולא מרוצים)?\n"
-            "9. האם התשובה מראה הבנה עסקית מעמיקה (משמעות, השפעה, המלצות)?\n"
-            "10. האם הרחבת על כל נקודה עם הסברים מפורטים ודוגמאות מרובות?\n"
-            "11. האם כל המספרים מדויקים מהנתונים?\n"
-            "12. האם כל השירותים קיימים בנתונים?\n"
-            "13. האם התשובה הגיונית ולוגית (לא שטויות)?\n"
-            "14. האם התשובה קשורה לשאלה שנשאלה?\n"
-            "15. האם התשובה מפורטת ומקצועית?\n"
-            "16. האם התשובה כוללת תובנות עסקיות והמלצות מעשיות?\n"
-            "\n"
-            "אם התשובה לא עומדת בכל הקריטריונים לעיל, כתוב תשובה חדשה שעומדת בכל הקריטריונים.\n"
-        )
-
-        # Compute comprehensive aggregates locally to include in the prompt
-        try:
-            df = load_feedback()
-            total = len(df)
-            
-            # Level distribution
-            level_dist = df[settings.level_column].value_counts().sort_index().to_dict()
-            level_percentages = {k: f"{(v/total*100):.1f}%" for k, v in level_dist.items()}
-            
-            # Service statistics
-            counts_by_service = df.groupby(settings.service_column).size().sort_values(ascending=False).head(15).to_dict()
-            avg_level_by_service = df.groupby(settings.service_column)[settings.level_column].mean().sort_values(ascending=False).head(15).to_dict()
-            
-            # High vs Low ratings
-            high_ratings = df[df[settings.level_column] >= 4]
-            low_ratings = df[df[settings.level_column] <= 2]
-            high_count = len(high_ratings)
-            low_count = len(low_ratings)
-            
-            # Service-level analysis
-            low_level_df = df[df[settings.level_column] < 3]
-            low_level_counts = low_level_df.groupby(settings.service_column).size().sort_values(ascending=False).head(10).to_dict()
-            high_level_df = df[df[settings.level_column] >= 4]
-            high_level_counts = high_level_df.groupby(settings.service_column).size().sort_values(ascending=False).head(10).to_dict()
-            
-            # Sample texts by rating
-            high_sample_texts = high_ratings[settings.text_column].head(5).tolist() if len(high_ratings) > 0 else []
-            low_sample_texts = low_ratings[settings.text_column].head(5).tolist() if len(low_ratings) > 0 else []
-            
-            aggregates_str = (
-                f"סטטיסטיקות כלליות:\n"
-                f"- סך הכל משובים: {total}\n"
-                f"- חלוקת דירוגים: {level_dist} ({level_percentages})\n"
-                f"- משתמשים מרוצים (דירוג 4-5): {high_count} ({(high_count/total*100):.1f}%)\n"
-                f"- משתמשים לא מרוצים (דירוג 1-2): {low_count} ({(low_count/total*100):.1f}%)\n"
-                f"\n"
-                f"שירותים עם הכי הרבה משובים: {counts_by_service}\n"
-                f"שירותים עם ממוצע דירוג גבוה (4+): {dict(list(avg_level_by_service.items())[:10])}\n"
-                f"שירותים עם הכי הרבה דירוגים נמוכים (1-2): {low_level_counts}\n"
-                f"שירותים עם הכי הרבה דירוגים גבוהים (4-5): {high_level_counts}\n"
-                f"\n"
-                f"דוגמאות משובים עם דירוג גבוה (4-5):\n" + "\n".join([f"  - {t[:200]}" for t in high_sample_texts[:3]]) + "\n"
-                f"\n"
-                f"דוגמאות משובים עם דירוג נמוך (1-2):\n" + "\n".join([f"  - {t[:200]}" for t in low_sample_texts[:3]]) + "\n"
-            )
-        except Exception as e:
-            aggregates_str = f"סטטיסטיקות: שגיאה בטעינת נתונים - {str(e)}\n"
-
-        # Special-case: the user asked to split into N topics (e.g., "חלק את המשובים ל5 נושאים")
-        import re
-        m = re.search(r"(\d+)\s*נוש", query)
-        topic_split_pattern = ("חלק" in query and ("נוש" in query or "נושא" in query)) or m or ("נושא" in query and "מרכזי" in query and "תחום" in query)
-        if topic_split_pattern:
-            try:
-                n_topics = int(m.group(1)) if m else 5
-                texts = df[settings.text_column].astype(str).tolist()
-                embeddings = self.embedder.encode(texts)
-                from .topics import kmeans_topics
-                res = kmeans_topics(embeddings, num_topics=n_topics)
-
-                # Build a comprehensive summary of clusters with detailed examples and statistics
-                clusters: Dict[int, list] = {}
-                cluster_services: Dict[int, Dict[str, int]] = {}  # service counts per cluster
-                cluster_levels: Dict[int, Dict[int, int]] = {}  # level distribution per cluster
-                
-                for label, text, row_idx in zip(res.labels, texts, range(len(texts))):
-                    cluster_id = int(label)
-                    clusters.setdefault(cluster_id, []).append(text)
-                    
-                    # Track service distribution per cluster
-                    if cluster_id not in cluster_services:
-                        cluster_services[cluster_id] = {}
-                    if cluster_id not in cluster_levels:
-                        cluster_levels[cluster_id] = {}
-                    
-                    service = df.iloc[row_idx].get(settings.service_column, "Unknown")
-                    level = df.iloc[row_idx].get(settings.level_column, 0)
-                    cluster_services[cluster_id][service] = cluster_services[cluster_id].get(service, 0) + 1
-                    cluster_levels[cluster_id][level] = cluster_levels[cluster_id].get(level, 0) + 1
-
-                cluster_summaries = []
-                for tid in sorted(clusters.keys()):
-                    items = clusters[tid]
-                    count = len(items)
-                    percentage = (count / total_records * 100) if total_records > 0 else 0
-                    
-                    # Get top services for this cluster
-                    top_services = sorted(cluster_services[tid].items(), key=lambda x: x[1], reverse=True)[:5]
-                    services_str = ", ".join([f"{svc} ({cnt})" for svc, cnt in top_services])
-                    
-                    # Get level distribution
-                    level_dist = cluster_levels[tid]
-                    avg_level = sum(level * count for level, count in level_dist.items()) / sum(level_dist.values()) if level_dist else 0
-                    high_ratings = sum(count for level, count in level_dist.items() if level >= 4)
-                    low_ratings = sum(count for level, count in level_dist.items() if level <= 2)
-                    
-                    # Get diverse sample texts (not just first 3)
-                    sample_size = min(10, len(items))
-                    step = max(1, len(items) // sample_size)
-                    sample = [items[i] for i in range(0, len(items), step)][:5]
-                    
-                    cluster_summaries.append(
-                        f"נושא {tid + 1}:\n"
-                        f"  - מספר משובים: {count} ({(percentage):.1f}% מכלל המשובים)\n"
-                        f"  - ממוצע דירוג: {avg_level:.2f}\n"
-                        f"  - דירוגים גבוהים (4-5): {high_ratings} ({(high_ratings/count*100):.1f}% מהנושא)\n"
-                        f"  - דירוגים נמוכים (1-2): {low_ratings} ({(low_ratings/count*100):.1f}% מהנושא)\n"
-                        f"  - שירותים עיקריים: {services_str}\n"
-                        f"  - דוגמאות משובים:\n" + "\n".join([f"    * {t[:150]}{'...' if len(t) > 150 else ''}" for t in sample])
-                    )
-
-                clusters_str = "\n\n".join(cluster_summaries)
-
-                prompt = (
-                    f"{instruction}\n\n{lang_instruction}.\n\n"
-                    f"שאלת המשתמש:\n{query}\n\n"
-                    f"סטטיסטיקות כלליות של כל הנתונים:\n{aggregates_str}\n\n"
-                    f"ניתוח נושאים (clusters) - {n_topics} נושאים שזוהו:\n{clusters_str}\n\n"
-                    f"הוראות מפורטות לניתוח נושאים:\n"
-                    f"1. עבור כל נושא (נושא 1, נושא 2, וכו'), תן:\n"
-                    f"   א. שם נושא קצר ומשמעותי (2-4 מילים בעברית) שמתאר את התחום/הנושא המרכזי עליו המשתמשים מדברים\n"
-                    f"      - השם צריך להיות ברור ומשמעותי, לא גנרי (לא 'נושא 1' אלא משהו כמו 'בעיות טכניות' או 'שדות לא ערוכים')\n"
-                    f"      - השם צריך לשקף את התוכן המרכזי של המשובים בנושא זה\n"
-                    f"   ב. תיאור מפורט של הנושא (3-5 משפטים) שמסביר:\n"
-                    f"      - מה הנושא הזה? על מה המשתמשים מדברים?\n"
-                    f"      - מה הדפוסים המרכזיים? מה חוזר על עצמו?\n"
-                    f"      - מה המשתמשים אומרים? מה הם מרגישים?\n"
-                    f"      - אילו שירותים קשורים לנושא הזה?\n"
-                    f"      - מה רמת שביעות הרצון בנושא הזה? (תבסס על ממוצע הדירוג והחלוקה בין דירוגים גבוהים לנמוכים)\n"
-                    f"   ג. דוגמאות קונקרטיות מהמשובים (2-3 דוגמאות) שמדגימות את הנושא\n"
-                    f"      - צטט או תאר משובים ספציפיים מהדוגמאות שסופקו\n"
-                    f"      - הדוגמאות צריכות להמחיש את הנושא בצורה ברורה\n"
-                    f"   ד. תובנות עסקיות והמלצות מעשיות (2-3 משפטים)\n"
-                    f"      - מה המשמעות של הנושא הזה? מה ההשפעה על השירות?\n"
-                    f"      - מה צריך לעשות? מה הפעולות המומלצות?\n"
-                    f"\n"
-                    f"2. פורמט התשובה:\n"
-                    f"   - התחל עם משפט פתיחה קצר שמתאר את התמונה הכללית: 'ניתן לזהות {n_topics} נושאים מרכזיים במשובים...'\n"
-                    f"   - עבור כל נושא, כתוב פסקה מפורטת (5-7 משפטים) שכוללת את כל הנקודות לעיל (שם, תיאור, דוגמאות, תובנות)\n"
-                    f"   - כל נושא צריך להיות מוצג בבירור, עם שם בולט (למשל: 'נושא 1: [שם הנושא]')\n"
-                    f"   - סיים עם סיכום כללי (2-3 משפטים) שמסכם את הממצאים העיקריים\n"
-                    f"\n"
-                    f"3. כללי כתיבה:\n"
-                    f"   - השתמש במספרים המדויקים מהניתוח (כמה משובים בכל נושא, אחוזים, ממוצע דירוג, וכו')\n"
-                    f"   - ציין שירותים ספציפיים מהניתוח\n"
-                    f"   - השתמש בדוגמאות הקונקרטיות מהמשובים - צטט או תאר משובים ספציפיים\n"
-                    f"   - כתוב בעברית מקצועית וקולחת\n"
-                    f"   - תן תשובה מפורטת מאוד ומקיפה (לפחות 700-900 מילים בסך הכל, 8-12 פסקאות)\n"
-                    f"   - כל נושא צריך לקבל טיפול שווה ומפורט\n"
-                )
-            except Exception as e:
-                print(f"Error in topic clustering: {e}", flush=True)
-                # fallback to standard prompt if clustering fails
-                prompt = (
-                    f"{instruction}\n\n{lang_instruction}.\n\nUser query:\n{query}\n\nDataset aggregates:\n{aggregates_str}\n\nFeedback examples (truncated):\n{joined}\n\nPlease present a clear, actionable, and human-readable analysis."
-                )
-            # Send to LLM below
-        elif ("נמוך" in query and ("3" in query or "שלוש" in query)) or ("level < 3" in query) or ("ציון" in query and "3" in query and ("נמוך" in query or "מתחת" in query)) or ("נושא" in query and "מרכזי" in query and ("נמוך" in query or "ציון" in query)):
-            # User asks about items with level < 3 or main topic of low-rated feedback
-            try:
-                if df is None or len(df) == 0:
-                    raise ValueError("No data available")
-                low_level_df = df[df[settings.level_column] < 3].copy()
-                low_texts = low_level_df[settings.text_column].astype(str).tolist()
-                if low_texts:
-                    embeddings = self.embedder.encode(low_texts)
-                    from .topics import kmeans_topics
-                    # Use 3-5 topics depending on data size
-                    n_topics = min(5, max(3, len(low_texts) // 20))
-                    res = kmeans_topics(embeddings, num_topics=n_topics)
-                    
-                    clusters: Dict[int, list] = {}
-                    cluster_services: Dict[int, Dict[str, int]] = {}
-                    cluster_indices: Dict[int, list] = {}  # Store original indices for service/level lookup
-                    
-                    for idx, (label, text) in enumerate(zip(res.labels, low_texts)):
-                        cluster_id = int(label)
-                        clusters.setdefault(cluster_id, []).append(text)
-                        cluster_indices.setdefault(cluster_id, []).append(idx)
-                        
-                        if cluster_id not in cluster_services:
-                            cluster_services[cluster_id] = {}
-                        
-                        # Get service for this feedback
-                        original_idx = low_level_df.index[idx]
-                        service = df.iloc[original_idx].get(settings.service_column, "Unknown")
-                        cluster_services[cluster_id][service] = cluster_services[cluster_id].get(service, 0) + 1
-                    
-                    # Build comprehensive cluster summaries
-                    cluster_summaries = []
-                    for tid in sorted(clusters.keys()):
-                        items = clusters[tid]
-                        count = len(items)
-                        percentage = (count / len(low_texts) * 100) if low_texts else 0
-                        
-                        # Get top services
-                        top_services = sorted(cluster_services[tid].items(), key=lambda x: x[1], reverse=True)[:5]
-                        services_str = ", ".join([f"{svc} ({cnt})" for svc, cnt in top_services])
-                        
-                        # Get diverse sample texts
-                        sample_size = min(8, len(items))
-                        step = max(1, len(items) // sample_size)
-                        sample = [items[i] for i in range(0, len(items), step)][:5]
-                        
-                        cluster_summaries.append(
-                            f"נושא {tid + 1} (משובים עם דירוג נמוך):\n"
-                            f"  - מספר משובים: {count} ({(percentage):.1f}% מכלל המשובים עם דירוג נמוך)\n"
-                            f"  - שירותים עיקריים: {services_str}\n"
-                            f"  - דוגמאות משובים:\n" + "\n".join([f"    * {t[:150]}{'...' if len(t) > 150 else ''}" for t in sample])
-                        )
-                    
-                    clusters_str = "\n\n".join(cluster_summaries)
-                    
-                    # Identify the largest/most dominant cluster
-                    largest_cluster = max(clusters.items(), key=lambda x: len(x[1]))
-                    largest_tid = largest_cluster[0]
-                    largest_items = largest_cluster[1]
-                    largest_services = sorted(cluster_services[largest_tid].items(), key=lambda x: x[1], reverse=True)[:3]
-                    
-                else:
-                    clusters_str = "(לא נמצאו משובים עם דירוג נמוך)"
-                    largest_cluster = None
-                    largest_tid = None
-                    largest_items = []
-                    largest_services = []
-
-                prompt = (
-                    f"{instruction}\n\n{lang_instruction}.\n\n"
-                    f"שאלת המשתמש:\n{query}\n\n"
-                    f"סטטיסטיקות כלליות:\n{aggregates_str}\n\n"
-                    f"ניתוח נושאים במשובים עם דירוג נמוך (ציון < 3):\n{clusters_str}\n\n"
-                    f"הוראות מפורטות לניתוח:\n"
-                    f"1. זהה את הנושא המרכזי/הדומיננטי ביותר במשובים עם דירוג נמוך:\n"
-                    f"   - איזה נושא מופיע הכי הרבה? מה הנושא הגדול ביותר?\n"
-                    f"   - מה הנושא שמדאיג ביותר? מה הנושא שצריך לטפל בו בעדיפות?\n"
-                    f"\n"
-                    f"2. תן שם ברור ומשמעותי לנושא המרכזי (2-4 מילים בעברית):\n"
-                    f"   - השם צריך לשקף את הבעיה המרכזית או הנושא עליו המשתמשים מתלוננים\n"
-                    f"   - דוגמאות: 'בעיות טכניות במערכת', 'שדות לא ערוכים', 'חוסר בהירות בהנחיות'\n"
-                    f"\n"
-                    f"3. תאר את הנושא המרכזי בפירוט (5-7 משפטים):\n"
-                    f"   - מה הנושא הזה? על מה המשתמשים מתלוננים?\n"
-                    f"   - מה הבעיות הספציפיות? מה לא עובד?\n"
-                    f"   - מה הדפוסים המרכזיים? מה חוזר על עצמו?\n"
-                    f"   - אילו שירותים מושפעים ביותר? (ציין שמות שירותים ספציפיים ומספרים)\n"
-                    f"   - כמה משובים מתייחסים לנושא הזה? מה האחוז מכלל המשובים עם דירוג נמוך?\n"
-                    f"\n"
-                    f"4. כלול דוגמאות קונקרטיות מהמשובים (3-5 דוגמאות):\n"
-                    f"   - צטט או תאר משובים ספציפיים שמדגימים את הנושא המרכזי\n"
-                    f"   - הדוגמאות צריכות להמחיש את הבעיה בצורה ברורה\n"
-                    f"   - השתמש בדוגמאות מהנושא הגדול ביותר (נושא {largest_tid + 1 if largest_tid is not None else 'הגדול ביותר'})\n"
-                    f"\n"
-                    f"5. תובנות עסקיות והמלצות מעשיות (3-4 משפטים):\n"
-                    f"   - מה המשמעות של הנושא הזה? מה ההשפעה על השירות?\n"
-                    f"   - מה הסיכונים אם לא מטפלים בנושא הזה?\n"
-                    f"   - מה הפעולות המומלצות לתיקון? מה צריך לעשות בעדיפות גבוהה?\n"
-                    f"\n"
-                    f"6. פורמט התשובה:\n"
-                    f"   - התחל עם משפט פתיחה: 'הנושא המרכזי במשובים עם דירוג נמוך הוא...'\n"
-                    f"   - המשך עם שם הנושא (בולט, למשל: 'נוש�� מרכזי: [שם הנושא]')\n"
-                    f"   - המשך עם תיאור מפורט של הנושא (5-7 משפטים)\n"
-                    f"   - המשך עם דוגמאות קונקרטיות (3-5 דוגמאות)\n"
-                    f"   - סיים עם תובנות עסקיות והמלצות מעשיות\n"
-                    f"\n"
-                    f"7. כללי כתיבה:\n"
-                    f"   - השתמש במספרים המדויקים מהניתוח (כמה משובים, אחוזים, שירותים)\n"
-                    f"   - ציין שירותים ספציפיים מהניתוח\n"
-                    f"   - השתמש בדוגמאות הקונקרטיות מהמשובים - צטט או תאר משובים ספציפיים\n"
-                    f"   - כתוב בעברית מקצועית וקולחת\n"
-                    f"   - תן תשובה מפורטת מאוד ומקיפה (לפחות 600-800 מילים, 7-10 פסקאות)\n"
-                    f"   - התמקד בנושא המרכזי/הדומיננטי ביותר, לא בכל הנושאים\n"
-                )
-            except Exception as e:
-                print(f"Error in low-level topic analysis: {e}", flush=True)
-                prompt = (
-                    f"{instruction}\n\n{lang_instruction}.\n\nUser query:\n{query}\n\nDataset aggregates:\n{aggregates_str}\n\nFeedback examples (truncated):\n{joined}\n\nPlease present a clear, actionable, and human-readable analysis."
-                )
-        elif "שירותים" in query or "שירות" in query:
-            # User asked about services with issues vs services working well
-            try:
-                svc_stats = df.groupby(settings.service_column)[settings.level_column].agg(['mean','count']).sort_values('mean')
-                problematic = svc_stats[svc_stats['mean'] < 3].head(10).to_dict('index')
-                good = svc_stats[svc_stats['mean'] >= 4].head(10).to_dict('index')
-                svc_str = f"Problematic (mean<3): {problematic}\nWorking well (mean>=4): {good}\n"
-                prompt = (
-                    f"{instruction}\n\n{lang_instruction}.\n\n"
-                    f"שאלת המשתמש:\n{query}\n\n"
-                    f"סטטיסטיקות וניתוח הנתונים:\n{aggregates_str}\n\n"
-                    f"סטטיסטיקות ברמת שירות:\n{svc_str}\n\n"
-                    f"דוגמאות משובים רלוונטיים:\n{joined}\n\n"
-                    f"הוראות:\n"
-                    f"- תאר אילו שירותים יש להם בעיות חמורות (ציין שמות שירותים ספציפיים, ממוצע דירוג, מספר משובים)\n"
-                    f"- תאר אילו שירותים עובדים טוב (ציין שמות שירותים ספציפיים, ממוצע דירוג, מספר משובים)\n"
-                    f"- השווה בין שירותים עם בעיות לשירותים שעובדים טוב - מה ההבדל?\n"
-                    f"- תן המלצות מעשיות לתיקון ולניטור בעדיפות\n"
-                    f"- השתמש בדוגמאות מהמשובים שסופקו\n"
-                    f"- תן תשובה מפורטת (3-5 פסקאות) עם מספרים מדויקים\n"
-                )
-            except Exception:
-                prompt = (
-                    f"{instruction}\n\n{lang_instruction}.\n\nUser query:\n{query}\n\nDataset aggregates:\n{aggregates_str}\n\nFeedback examples (truncated):\n{joined}\n\nPlease present a clear, actionable, and human-readable analysis."
-                )
-        else:
-            prompt = (
-                f"{instruction}\n\n{lang_instruction}.\n\n"
-                f"שאלת המשתמש:\n{query}\n\n"
-                f"סטטיסטיקות מקיפות של כל הנתונים:\n{aggregates_str}\n\n"
-                f"סיכום מקיף של כל הנתונים (כולל סיכומים לפי שירותים, דירוגים, ודוגמאות רלוונטיות):\n{joined}\n\n"
-                f"הוראות חשובות - אגרגציה חכמה ומבנה ברור (קריטי!):\n"
-                f"1. קודם כל, עשה אגרגציה חכמה של כל הנתונים:\n"
-                f"   - קרא ונתח את כל הסטטיסטיקות והסיכומים שסופקו\n"
-                f"   - זהה את הדפוסים והנושאים המרכזיים שחוזרים על עצמם\n"
-                f"   - הבן את התמונה הגדולה - מה המגמות הכלליות? מה הנושאים הדומיננטיים?\n"
-                f"   - השווה בין קבוצות שונות (מרוצים vs לא מרוצים, שירותים שונים)\n"
-                f"   - זהה קשרים והקשרים בין נושאים שונים\n"
-                f"\n"
-                f"2. רק אחרי שעשית אגרגציה חכמה - כתוב תשובה מסכמת ברורה ומסודרת:\n"
-                f"   - תשובה שמסכמת את הממצאים העיקריים מהאגרגציה\n"
-                f"   - תשובה שמראה הבנה עמוקה של הדפוסים והנושאים המרכזיים\n"
-                f"   - תשובה שמבוססת על ניתוח מעמיק, לא רק חיבור של משובים בודדים\n"
-                f"   - תשובה ברורה ומסודרת - לא גיבוב של מילים\n"
-                f"   - אל תכתוב: 'משתמש אחד אמר X, משתמש שני אמר Y'\n"
-                f"   - במקום זה, כתוב: 'נראה שיש דפוס ברור של X בקרב Y% מהמשתמשים'\n"
-                f"\n"
-                f"3. מבנה התשובה - חובה:\n"
-                f"   - פתיחה - סיכום מנהלים (פסקה אחת, 3-4 משפטים): סיכום כללי של התמונה הגדולה עם מספרים\n"
-                f"   - ניתוח מפורט לפי נושאים/דעות (3-5 פסקאות, כל פסקה 4-6 משפטים): כל פסקה בנושא/דעה מרכזי אחד\n"
-                f"   - השוואות וניתוח מעמיק (2-3 פסקאות): השוואות בין קבוצות ושירותים\n"
-                f"   - תובנות עסקיות והמלצות (2-3 פסקאות): משמעות, השפעה, המלצות\n"
-                f"   - סיכום (פסקה אחת, 2-3 משפטים): מסקנות עיקריות ונקודות מפתח\n"
-                f"\n"
-                f"4. פרטים נוספים:\n"
-                f"   - אתה רואה את כל הנתונים - תן תשובה קוהרנטית שמראה הבנה רחבה של כל הנתונים\n"
-                f"   - השתמש בסטטיסטיקות הכלליות כדי להבין את התמונה הגדולה\n"
-                f"   - השתמש בסיכומים לפי שירותים ודירוגים כדי לזהות דפוסים\n"
-                f"   - כששואלים על רגשות/תחושות/דעות:\n"
-                f"     * התחל עם סיכום כללי קצר (2-3 משפטים) שמתאר את התמונה הגדולה\n"
-                f"     * המשך עם ניתוח של המשתמשים המרוצים (דירוג 4-5) - מה הם אומרים? מה הם אוהבים? כלול דוגמאות קונקרטיות\n"
-                f"     * המשך עם ניתוח של המשתמשים הלא מרוצים (דירוג 1-2) - מה הם אומרים? מה הבעיות? כלול בעיות ספציפיות עם דוגמאות\n"
-                f"     * סיים עם סיכום והמלצות\n"
-                f"   - השווה בין קבוצות משתמשים (מרוצים vs לא מרוצים) ושירותים שונים - מה המשמעות?\n"
-                f"   - ציין שירותים ספציפיים ומספרים מדויקים מהנתונים\n"
-                f"   - תן תשובה מפורטת מאוד (7-10 פסקאות, לפחות 600-800 מילים) המנתחת את הנתונים לעומק\n"
-                f"   - תשובה שכוללת כמה דעות/נושאים מרכזיים (לא רק נושא אחד)\n"
-                f"   - כלול תובנות עסקיות מעמיקות: מה המשמעות של הממצאים? מה ההשפעה על השירות?\n"
-                f"   - כלול המלצות מעשיות וקונקרטיות - מה צריך לעשות?\n"
-                f"   - כתוב בעברית מקצועית וקולחת - כאילו אתה אנליסט שמסביר את הממצאים למנהל\n"
-                f"   - לפני שליחת התשובה, בדוק פעמיים: האם עשית אגרגציה חכמה? האם התשובה מסכמת את הממצאים העיקריים? האם היא מראה הבנה עמוקה של הדפוסים? האם התשובה ברורה ומסודרת עם מבנה ברור?\n"
-            )
-
-        # Try Gemini first
-        if settings.gemini_api_key and genai is not None:
-            try:
-                genai.configure(api_key=settings.gemini_api_key)
-                model = genai.GenerativeModel("gemini-1.5-flash")
-                # Use generation config for longer, more detailed and creative responses
-                # Higher temperature for more creative, comprehensive analysis that covers both sides
-                generation_config = {
-                    "temperature": 0.9,  # Higher temperature for more creative and comprehensive responses
-                    "top_p": 0.95,
-                    "top_k": 40,
-                    "max_output_tokens": 5000,  # Increased for longer, more comprehensive responses
-                }
-                resp = model.generate_content(prompt, generation_config=generation_config)
-                text = getattr(resp, "text", None)
-                if isinstance(text, str) and text.strip():
-                    # Validate and fix response if needed
-                    validated = self._validate_and_fix_response(text.strip(), query, aggregates_str)
-                    return validated
-            except Exception as e:
-                print(f"Gemini error: {e}", flush=True)
-                pass
-
-        # Fallback to OpenAI if available
-        if settings.openai_api_key and OpenAI is not None:
-            client = OpenAI(api_key=settings.openai_api_key)
-            try:
-                resp = client.chat.completions.create(
-                    model="gpt-4o-mini",
-                    messages=[{"role": "user", "content": prompt}],
-                    temperature=0.8,  # Higher temperature for more creative and comprehensive responses
-                    top_p=0.95,  # Higher top_p for more diverse and creative sampling
-                    max_tokens=4000,  # Increased for longer, more comprehensive responses
-                )
-                response_text = resp.choices[0].message.content
-                if response_text:
-                    # Validate and fix response if needed
-                    validated = self._validate_and_fix_response(response_text, query, aggregates_str)
-                    return validated
-            except Exception as e:
-                print(f"OpenAI error: {e}", flush=True)
-                pass
-
-        # Fallback: short extractive-ish synthesis
-        # Compose a short paragraph from top contexts
-        extract = " ".join(contexts[:5])
-        return extract
-
-    def _detect_level_filter(self, query: str) -> Optional[tuple]:
-        """Detect if query asks for specific level range (e.g., level < 3, דירוג נמוך)."""
-        query_lower = query.lower()
-        
-        # Check for low level queries (level < 3)
-        low_level_patterns = [
-            "דירוג נמוך", "ציון נמוך", "level < 3", "level<3", "דירוגים נמוכים",
-            "ציונים נמוכים", "מתחת ל-3", "מתחת ל3", "פחות מ-3", "פחות מ3",
-            "דירוג 1", "דירוג 2", "ציון 1", "ציון 2", "לא מרוצים"
-        ]
-        
-        # Check for high level queries (level >= 4)
-        high_level_patterns = [
-            "דירוג גבוה", "ציון גבוה", "level >= 4", "level>=4", "דירוגים גבוהים",
-            "ציונים גבוהים", "מעל 4", "מעל ל-4", "יותר מ-4", "יותר מ4",
-            "דירוג 4", "דירוג 5", "ציון 4", "ציון 5", "מרוצים"
-        ]
-        
-        if any(pattern in query_lower for pattern in low_level_patterns):
-            return (1, 2)  # Filter for level 1-2
-        elif any(pattern in query_lower for pattern in high_level_patterns):
-            return (4, 5)  # Filter for level 4-5
-        
-        return None
-
-    def query(self, query: str, top_k: int = 5) -> RetrievalOutput:
-        # Detect if query asks for specific level range
-        level_filter = self._detect_level_filter(query)
-        
-        # Use a very large retrieval to get comprehensive understanding of the data
-        # This ensures the model sees a broad representation of all feedback
-        adjusted_k = max(top_k, 100)  # Use 100 records for comprehensive RAG-based analysis
-        results = self.retrieve(query, top_k=adjusted_k, level_filter=level_filter)
-        contexts = [r.row[settings.text_column] for r in results]
-        # Use comprehensive synthesis that analyzes the full dataset, not just retrieved items
-        summary = self.synthesize(query, results, contexts, max_contexts=adjusted_k, level_filter=level_filter)
-        return RetrievalOutput(query=query, results=results, summary=summary)
-
-    def answer(self, query: str, top_k: int = 5) -> RetrievalOutput:
-        """Higher-level answer pipeline that handles counting/keyword questions explicitly.
-
-        For queries detected as counts (e.g., thanks, complaints, 'כמה'), compute counts over
-        the full dataset and return a short summary plus example contexts from retrieval.
-        Falls back to `query` for freeform QA.
-        """
-        # Detect level filter for all query types
-        level_filter = self._detect_level_filter(query)
-        
-        qtype, target = detect_query_type(query)
-        if qtype in ("count_thanks", "count_complaint", "count_keyword"):
-            # Use full dataset for accurate counts (with level filter if specified)
-            df = load_feedback()
-            if level_filter:
-                min_level, max_level = level_filter
-                df = df[(df[settings.level_column] >= min_level) & (df[settings.level_column] <= max_level)].copy()
-            resolved = resolve_count_from_type(df, qtype, target, text_column=settings.text_column)
-            count = int(resolved.get("count", 0))
-            # Friendly, language-aware summary
-            is_hebrew = any('\u0590' <= ch <= '\u05FF' for ch in query)
-            if resolved.get("label") == "thanks":
-                summary = (f"{count} משובים מכילים ביטויי תודה." if is_hebrew
-                           else f"{count} feedback entries contain thanks.")
-            elif resolved.get("label") == "complaint_not_working":
-                summary = (f"{count} משובים מתארים בעיות/אלמנטים שלא עובדים." if is_hebrew
-                           else f"{count} feedback entries report elements not working.")
-            else:
-                label = resolved.get("label", "")
-                if label.startswith("keyword:"):
-                    phrase = label.split("keyword:", 1)[1]
-                    summary = (f"{count} משובים מכילים את הביטוי '{phrase}'." if is_hebrew
-                               else f"{count} feedback entries contain the phrase '{phrase}'.")
-                else:
-                    summary = (f"{count} משובים נמצאו." if is_hebrew else f"{count} feedback entries found.")
-
-            # Provide examples from semantic retrieval for context (with level filter)
-            results = self.retrieve(query, top_k=top_k, level_filter=level_filter)
-            return RetrievalOutput(query=query, results=results, summary=summary)
-
-        # Fallback to semantic QA (which already handles level filter)
-        return self.query(query, top_k=top_k)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--ingest", action="store_true", help="Ingest CSV and build index")
-    parser.add_argument("--query", type=str, default=None, help="Run a semantic query")
-    parser.add_argument("--top_k", type=int, default=5, help="Top K results")
-    args = parser.parse_args()
-
-    svc = RAGService()
-    if args.ingest:
-        svc.ingest()
-        print("Ingest completed.")
-    if args.query:
-        out = svc.query(args.query, top_k=args.top_k)
-        print("Summary:", out.summary)
-        for r in out.results:
-            print(f"[{r.score:.3f}] {r.row.get('ServiceName','')} | {r.row.get('Text','')[:200]}")
-
-
-if __name__ == "__main__":
-    main()
-

app/sentiment.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-"""Sentiment analysis helpers using Hugging Face transformers.
-
-This module provides a cached sentiment pipeline to analyze lists of texts.
-The model used (`cardiffnlp/twitter-xlm-roberta-base-sentiment`) is multilingual and
-works reasonably well for short feedback messages. The pipeline is cached to avoid
-reloading the model for each call.
-"""
-
-from functools import lru_cache
-from typing import List, Dict
-
-from transformers import pipeline  # type: ignore
-
-
-@lru_cache(maxsize=1)
-def get_sentiment_pipeline():
-    """Load sentiment analysis pipeline with fallback options."""
-    import os
-    os.environ['TOKENIZERS_PARALLELISM'] = 'false'
-    
-    try:
-        # Try DistilBERT which works well for multilingual text (supports Hebrew)
-        return pipeline(
-            "sentiment-analysis",
-            model="nlptown/bert-base-multilingual-uncased-sentiment",
-            use_fast=False
-        )
-    except Exception as e1:
-        try:
-            # Fallback to simpler model
-            return pipeline("text-classification", model="gpt2", use_fast=False)
-        except Exception as e2:
-            # Final fallback: return a mock pipeline for development
-            import warnings
-            warnings.warn(f"Could not load sentiment models: {e1}, {e2}. Using mock pipeline.")
-            class MockPipeline:
-                def __call__(self, texts, **kwargs):
-                    return [{"label": "NEUTRAL", "score": 0.5} for _ in texts]
-            return MockPipeline()
-
-
-def analyze_sentiments(texts: List[str]) -> List[Dict[str, float | str]]:
-    clf = get_sentiment_pipeline()
-    outputs = clf(texts, truncation=True)
-    results: List[Dict[str, float | str]] = []
-    for out in outputs:
-        label = out.get("label", "")
-        score = float(out.get("score", 0.0))
-        results.append({"label": label, "score": score})
-    return results
-

app/sql_service.py

@@ -17,7 +17,6 @@ from dataclasses import dataclass
 from typing import List, Dict, Any, Optional
 import pandas as pd
 import sqlite3
-from io import StringIO
 
 from .config import settings
 from .data_loader import load_feedback
@@ -35,7 +34,14 @@ except Exception:
 
 @dataclass
 class SQLQueryResult:
-    """Result of a single SQL query execution."""
+    """
+    Result of a single SQL query execution.
+    
+    Attributes:
+        query: The SQL query that was executed
+        result: DataFrame containing the query results (empty if error occurred)
+        error: Error message if query failed, None if successful
+    """
     query: str
     result: pd.DataFrame
     error: Optional[str] = None
@@ -43,7 +49,16 @@ class SQLQueryResult:
 
 @dataclass
 class AnalysisResult:
-    """Complete analysis result."""
+    """
+    Complete analysis result from processing a user query.
+    
+    Attributes:
+        user_query: The original question asked by the user
+        sql_queries: List of SQL queries that were generated and executed
+        query_results: Results from executing each SQL query
+        summary: Final synthesized answer in natural language
+        visualizations: Optional list of visualization specifications for frontend rendering
+    """
     user_query: str
     sql_queries: List[str]
     query_results: List[SQLQueryResult]
@@ -52,14 +67,42 @@ class AnalysisResult:
 
 
 class SQLFeedbackService:
-    """Service for SQL-based feedback analysis."""
+    """
+    Main service for SQL-based feedback analysis.
+    
+    This service implements a 4-stage pipeline:
+    1. Generate SQL queries from natural language questions (using LLM)
+    2. Execute SQL queries on feedback data (using SQLite in-memory)
+    3. Synthesize comprehensive answers from query results (using LLM)
+    4. Generate visualization specifications for results
+    
+    The service also includes automatic quality evaluation and improvement
+    of generated answers to ensure high-quality responses.
+    """
     
     def __init__(self):
+        """
+        Initialize the SQL feedback service.
+        
+        Loads feedback data from CSV into memory. If loading fails,
+        the service will still initialize but will raise errors when
+        trying to process queries.
+        """
         self.df: Optional[pd.DataFrame] = None
         self._load_data()
     
-    def _load_data(self):
-        """Load feedback data into memory."""
+    def _load_data(self) -> None:
+        """
+        Load feedback data from CSV file into memory.
+        
+        The data is loaded once at initialization and kept in memory
+        for fast query execution. If the CSV file is missing or invalid,
+        an error is logged but the service continues to initialize.
+        
+        Raises:
+            FileNotFoundError: If CSV file doesn't exist (handled internally)
+            ValueError: If CSV is missing required columns (handled internally)
+        """
         try:
             self.df = load_feedback()
             print(f"Loaded {len(self.df)} feedback records", flush=True)
@@ -68,16 +111,45 @@ class SQLFeedbackService:
             self.df = None
     
     def _get_schema_info(self) -> str:
-        """Get schema information for the feedback table."""
+        """
+        Generate schema information string for the feedback table.
+        
+        This information is provided to the LLM when generating SQL queries
+        to help it understand the data structure and available columns.
+        
+        Returns:
+            A formatted string describing the table schema, column types,
+            and basic statistics. Used in prompts for SQL query generation.
+        
+        Note:
+            If CreationDate column exists, the function attempts to parse
+            dates and include the date range in the schema info.
+        """
         if self.df is None:
             return "No data available"
         
+        # Check if CreationDate exists and get date range
+        # This helps the LLM understand temporal queries
+        date_info = ""
+        if 'CreationDate' in self.df.columns:
+            try:
+                # Try to parse dates to provide useful date range information
+                df_dates = pd.to_datetime(self.df['CreationDate'], errors='coerce')
+                valid_dates = df_dates.dropna()
+                if len(valid_dates) > 0:
+                    min_date = valid_dates.min()
+                    max_date = valid_dates.max()
+                    date_info = f"\n- CreationDate: תאריך וזמן הזנת הפידבק (תאריך/זמן). טווח תאריכים: {min_date.strftime('%Y-%m-%d')} עד {max_date.strftime('%Y-%m-%d')}"
+            except Exception:
+                # If date parsing fails, still include the column info
+                date_info = "\n- CreationDate: תאריך וזמן הזנת הפידבק (תאריך/זמן)"
+        
         schema_info = f"""
 טבלת Feedback מכילה את השדות הבאים:
 - ID: מזהה ייחודי של כל משוב (מספר שלם)
 - ServiceName: שם השירות הדיגיטלי (טקסט)
 - Level: הציון שהמשתמש נתן לשירות (מספר שלם מ-1 עד 5, כאשר 1=גרוע, 5=מעולה)
-- Text: הטקסט החופשי שהמשתמש הזין כחלק מהפידבק (טקסט)
+- Text: הטקסט החופשי שהמשתמש הזין כחלק מהפידבק (טקסט){date_info}
 
 סטטיסטיקות כלליות:
 - סך הכל משובים: {len(self.df)}
@@ -133,16 +205,18 @@ class SQLFeedbackService:
 
 המשימה שלך: צור 1 עד 5 שאילתות SQL שיעזרו לענות על השאלה. כל שאילתה צריכה להיות שימושית וממוקדת.
 
-כללים חשובים:
-1. השתמש בשמות השדות המדויקים: ID, ServiceName, Level, Text
-2. Level הוא מספר שלם מ-1 עד 5 (1=גרוע, 5=מעולה)
-3. ServiceName הוא טקסט
-4. Text הוא הטקסט החופשי של המשוב
-5. כל שאילתה צריכה להיות תקפה SQLite
-6. השתמש בפונקציות SQL סטנדרטיות: COUNT, AVG, GROUP BY, WHERE, LIKE, etc.
-7. אם השאלה מתייחסת לטקסט, השתמש ב-LIKE או INSTR לחיפוש
-8. אם השאלה מתייחסת לדירוגים, השתמש ב-Level עם תנאים מתאימים
-9. אם השאלה מתייחסת לשירותים, השתמש ב-ServiceName
+       כללים חשובים:
+       1. השתמש בשמות השדות המדויקים: ID, ServiceName, Level, Text, CreationDate
+       2. Level הוא מספר שלם מ-1 עד 5 (1=גרוע, 5=מעולה)
+       3. ServiceName הוא טקסט
+       4. Text הוא הטקסט החופשי של המשוב
+       5. CreationDate הוא תאריך וזמן (תאריך/זמן) - ניתן להשתמש בו לשאילתות על תאריכים, תקופות זמן, מגמות לאורך זמן
+       6. כל שאילתה צריכה להיות תקפה SQLite
+       7. השתמש בפונקציות SQL סטנדרטיות: COUNT, AVG, GROUP BY, WHERE, LIKE, DATE(), strftime(), etc.
+       8. אם השאלה מתייחסת לטקסט, השתמש ב-LIKE או INSTR לחיפוש
+       9. אם השאלה מתייחסת לדירוגים, השתמש ב-Level עם תנאים מתאימים
+       10. אם השאלה מתייחסת לשירותים, השתמש ב-ServiceName
+       11. אם השאלה מתייחסת לתאריכים, תקופות זמן, או מגמות לאורך זמן - השתמש ב-CreationDate עם פונקציות תאריך כמו DATE(), strftime('%Y-%m', CreationDate), etc.
 
 פורמט התשובה - JSON בלבד:
 {{
@@ -159,7 +233,7 @@ class SQLFeedbackService:
         if settings.gemini_api_key and genai is not None:
             try:
                 genai.configure(api_key=settings.gemini_api_key)
-                model = genai.GenerativeModel("gemini-1.5-flash")
+                model = genai.GenerativeModel("gemini-2.0-flash")
                 response = model.generate_content(prompt)
                 text = getattr(response, "text", None)
                 if text:
@@ -186,10 +260,28 @@ class SQLFeedbackService:
         return []
     
     def _parse_sql_queries(self, text: str) -> List[str]:
-        """Parse SQL queries from LLM response."""
-        # Try to extract JSON
+        """
+        Parse SQL queries from LLM response text.
+        
+        The LLM is instructed to return JSON, but sometimes it may include
+        markdown formatting or return SQL directly. This function handles
+        multiple formats for robustness.
+        
+        Args:
+            text: Raw text response from LLM (may be JSON, markdown, or plain SQL)
+        
+        Returns:
+            List of SQL query strings, cleaned and validated.
+            Empty list if parsing fails completely.
+        
+        Strategy:
+            1. First, try to parse as JSON (expected format)
+            2. If that fails, try to extract SQL queries using regex
+            3. Return empty list if both methods fail
+        """
+        # Try to extract JSON first (expected format)
         try:
-            # Remove markdown code blocks if present
+            # Remove markdown code blocks if present (LLM sometimes adds these)
             text = re.sub(r'```json\s*', '', text)
             text = re.sub(r'```\s*', '', text)
             text = text.strip()
@@ -199,34 +291,62 @@ class SQLFeedbackService:
             if isinstance(data, dict) and "queries" in data:
                 queries = data["queries"]
                 if isinstance(queries, list):
+                    # Filter out empty or invalid queries
                     return [q for q in queries if isinstance(q, str) and q.strip()]
         except Exception:
+            # JSON parsing failed, try fallback method
             pass
         
-        # Fallback: try to extract SQL queries directly
+        # Fallback: try to extract SQL queries directly using regex
+        # This handles cases where LLM returns SQL without JSON wrapper
         sql_pattern = r'SELECT\s+.*?(?=\n\n|\nSELECT|$)'
         matches = re.findall(sql_pattern, text, re.IGNORECASE | re.DOTALL)
         if matches:
             return [m.strip() for m in matches]
         
+        # If all parsing methods fail, return empty list
+        # The calling function will handle this gracefully
         return []
     
     def _execute_sql_queries(self, sql_queries: List[str]) -> List[SQLQueryResult]:
-        """Execute SQL queries on the feedback DataFrame."""
+        """
+        Execute SQL queries on the feedback DataFrame using SQLite in-memory database.
+        
+        This method creates a temporary SQLite database in memory, loads the
+        feedback DataFrame into it, and executes each SQL query. Errors are
+        caught per-query so one failing query doesn't stop the others.
+        
+        Args:
+            sql_queries: List of SQL query strings to execute
+        
+        Returns:
+            List of SQLQueryResult objects, one per query. Each result contains
+            either the query results (DataFrame) or an error message.
+        
+        Implementation details:
+            - Uses SQLite in-memory database (':memory:') for fast execution
+            - DataFrame is loaded into table named 'feedback'
+            - Each query is executed independently (errors don't cascade)
+            - Connection is always closed in finally block for safety
+        """
         if self.df is None:
             return []
         
         results = []
         
         # Create in-memory SQLite database
+        # Using in-memory is fast and doesn't require disk I/O
         conn = sqlite3.connect(':memory:')
         try:
-            # Write DataFrame to SQLite
+            # Write DataFrame to SQLite table named 'feedback'
+            # if_exists='replace' ensures clean state on each execution
             self.df.to_sql('feedback', conn, index=False, if_exists='replace')
             
+            # Execute each query independently
+            # This allows partial success - if one query fails, others can still succeed
             for query in sql_queries:
                 try:
-                    # Execute query
+                    # Execute query and get results as DataFrame
                     result_df = pd.read_sql_query(query, conn)
                     results.append(SQLQueryResult(
                         query=query,
@@ -234,23 +354,116 @@ class SQLFeedbackService:
                         error=None
                     ))
                 except Exception as e:
+                    # Store error but continue with other queries
                     results.append(SQLQueryResult(
                         query=query,
-                        result=pd.DataFrame(),
+                        result=pd.DataFrame(),  # Empty DataFrame on error
                         error=str(e)
                     ))
         finally:
+            # Always close connection, even if errors occur
             conn.close()
         
         return results
     
+    def _evaluate_answer_quality(self, query: str, answer: str) -> tuple[float, str]:
+        """
+        Evaluate the quality of an answer using an LLM reviewer.
+        
+        Returns:
+            tuple: (score 0-100, feedback/reasoning)
+        """
+        evaluation_prompt = f"""אתה בודק איכות תשובות. הערך את התשובה הבאה:
+
+שאלת המשתמש: {query}
+
+התשובה שניתנה:
+{answer}
+
+הערך את התשובה לפי הקריטריונים הבאים (0-100):
+1. האם התשובה עונה ישירות על השאלה? (0-30 נקודות)
+2. האם התשובה מבוססת על הנתונים? (0-25 נקודות)
+3. האם התשובה מפורטת ומקיפה? (0-20 נקודות)
+4. האם התשובה ברורה ומובנת? (0-15 נקודות)
+5. האם התשובה כוללת תובנות עסקיות? (0-10 נקודות)
+
+תן ציון כולל (0-100) והסבר קצר (2-3 משפטים) למה הציון הזה.
+
+פורמט התשובה - JSON בלבד:
+{{
+  "score": <מספר 0-100>,
+  "reasoning": "<הסבר קצר>"
+}}
+
+תן רק את ה-JSON, ללא טקסט נוסף."""
+
+        # Try Gemini first
+        if settings.gemini_api_key and genai is not None:
+            try:
+                genai.configure(api_key=settings.gemini_api_key)
+                model = genai.GenerativeModel("gemini-2.0-flash")
+                response = model.generate_content(evaluation_prompt)
+                text = getattr(response, "text", None)
+                if text:
+                    # Try to parse JSON from response
+                    # Extract JSON (may be wrapped in markdown or other text)
+                    json_match = re.search(r'\{[^}]+\}', text, re.DOTALL)
+                    if json_match:
+                        try:
+                            data = json.loads(json_match.group())
+                            score = float(data.get('score', 0))
+                            reasoning = data.get('reasoning', '')
+                            return score, reasoning
+                        except (json.JSONDecodeError, ValueError, KeyError):
+                            pass
+            except Exception as e:
+                print(f"Gemini error in evaluation: {e}", flush=True)
+        
+        # Fallback to OpenAI
+        if settings.openai_api_key and OpenAI is not None:
+            try:
+                client = OpenAI(api_key=settings.openai_api_key)
+                response = client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[{"role": "user", "content": evaluation_prompt}],
+                    temperature=0.3,
+                )
+                text = response.choices[0].message.content
+                if text:
+                    # Try to parse JSON from response
+                    json_match = re.search(r'\{[^}]+\}', text, re.DOTALL)
+                    if json_match:
+                        try:
+                            data = json.loads(json_match.group())
+                            score = float(data.get('score', 0))
+                            reasoning = data.get('reasoning', '')
+                            return score, reasoning
+                        except (json.JSONDecodeError, ValueError, KeyError):
+                            pass
+            except Exception as e:
+                print(f"OpenAI error in evaluation: {e}", flush=True)
+        
+        # Default: return high score if evaluation fails (don't block)
+        return 85.0, "לא ניתן להעריך - מחזיר ציון ברירת מחדל"
+    
     def _synthesize_answer(self, query: str, sql_queries: List[str], 
-                          query_results: List[SQLQueryResult]) -> str:
+                          query_results: List[SQLQueryResult], max_retries: int = 2) -> str:
         """
         Use LLM to synthesize a comprehensive answer from:
         - User query
         - SQL queries that were executed
         - Results of those queries
+        
+        Includes quality evaluation and automatic improvement if score < 80.
+        
+        Args:
+            query: The user's original question
+            sql_queries: List of SQL queries that were executed
+            query_results: Results from executing those queries
+            max_retries: Maximum number of retry attempts if quality is low
+        
+        Returns:
+            Final synthesized answer
         """
         # Format query results for the prompt
         results_text = ""
@@ -300,7 +513,7 @@ class SQLFeedbackService:
         if settings.gemini_api_key and genai is not None:
             try:
                 genai.configure(api_key=settings.gemini_api_key)
-                model = genai.GenerativeModel("gemini-1.5-flash")
+                model = genai.GenerativeModel("gemini-2.0-flash")
                 generation_config = {
                     "temperature": 0.8,
                     "top_p": 0.95,
@@ -310,7 +523,49 @@ class SQLFeedbackService:
                 response = model.generate_content(prompt, generation_config=generation_config)
                 text = getattr(response, "text", None)
                 if text and text.strip():
-                    return text.strip()
+                    answer = text.strip()
+                    
+                    # Evaluate answer quality
+                    score, reasoning = self._evaluate_answer_quality(query, answer)
+                    print(f"Answer quality score: {score:.1f}/100 - {reasoning}", flush=True)
+                    
+                    # If score is below 80, try to improve
+                    if score < 80 and max_retries > 0:
+                        print(f"Answer quality below threshold (80). Attempting improvement...", flush=True)
+                        improvement_prompt = f"""התשובה הקודמת קיבלה ציון {score}/100. הסיבה: {reasoning}
+
+שאלת המשתמש: {query}
+
+התשובה הקודמת:
+{answer}
+
+תוצאות השאילתות:
+{results_text}
+
+כתוב תשובה משופרת שמתמקדת יותר בשאלה המקורית, מבוססת יותר על הנתונים, ומפורטת יותר.
+התשובה חייבת לענות ישירות על השאלה: {query}
+
+דרישות:
+1. תשובה מפורטת ומקיפה (5-7 פסקאות, 400-600 מילים)
+2. תשובה שמתמקדת ישירות בשאלה שנשאלה
+3. כלול מספרים מדויקים מהתוצאות
+4. הסבר את המשמעות העסקית של הממצאים
+5. כלול המלצות מעשיות לשיפור
+6. כתוב בעברית מקצועית וקולחת"""
+                        
+                        try:
+                            response = model.generate_content(improvement_prompt, generation_config=generation_config)
+                            improved_text = getattr(response, "text", None)
+                            if improved_text and improved_text.strip():
+                                # Re-evaluate improved answer
+                                improved_score, improved_reasoning = self._evaluate_answer_quality(query, improved_text.strip())
+                                print(f"Improved answer quality score: {improved_score:.1f}/100 - {improved_reasoning}", flush=True)
+                                if improved_score > score:
+                                    return improved_text.strip()
+                        except Exception as e:
+                            print(f"Error improving answer: {e}", flush=True)
+                    
+                    return answer
             except Exception as e:
                 print(f"Gemini error in synthesis: {e}", flush=True)
         
@@ -325,8 +580,47 @@ class SQLFeedbackService:
                     max_tokens=3000,
                 )
                 text = response.choices[0].message.content
-                if text:
-                    return text.strip()
+                if text and text.strip():
+                    answer = text.strip()
+                    
+                    # Evaluate answer quality
+                    score, reasoning = self._evaluate_answer_quality(query, answer)
+                    print(f"Answer quality score: {score:.1f}/100 - {reasoning}", flush=True)
+                    
+                    # If score is below 80, try to improve
+                    if score < 80 and max_retries > 0:
+                        print(f"Answer quality below threshold (80). Attempting improvement...", flush=True)
+                        improvement_prompt = f"""התשובה הקודמת קיבלה ציון {score}/100. הסיבה: {reasoning}
+
+שאלת המשתמש: {query}
+
+התשובה הקודמת:
+{answer}
+
+תוצאות השאילתות:
+{results_text}
+
+כתוב תשובה משופרת שמתמקדת יותר בשאלה המקורית, מבוססת יותר על הנתונים, ומפורטת יותר.
+התשובה חייבת לענות ישירות על השאלה: {query}"""
+                        
+                        try:
+                            response = client.chat.completions.create(
+                                model="gpt-4o-mini",
+                                messages=[{"role": "user", "content": improvement_prompt}],
+                                temperature=0.8,
+                                max_tokens=3000,
+                            )
+                            improved_text = response.choices[0].message.content
+                            if improved_text and improved_text.strip():
+                                # Re-evaluate improved answer
+                                improved_score, improved_reasoning = self._evaluate_answer_quality(query, improved_text.strip())
+                                print(f"Improved answer quality score: {improved_score:.1f}/100 - {improved_reasoning}", flush=True)
+                                if improved_score > score:
+                                    return improved_text.strip()
+                        except Exception as e:
+                            print(f"Error improving answer: {e}", flush=True)
+                    
+                    return answer
             except Exception as e:
                 print(f"OpenAI error in synthesis: {e}", flush=True)
         
@@ -336,11 +630,32 @@ class SQLFeedbackService:
     def _generate_visualizations(self, query_results: List[SQLQueryResult]) -> Optional[List[Dict[str, Any]]]:
         """
         Generate visualization specifications for query results.
-        Returns a list of visualization configs (for frontend to render).
+        
+        This function analyzes the structure of query results and automatically
+        determines the best visualization type (bar, line, scatter, histogram).
+        The specifications are returned as dictionaries that the frontend can
+        use with Chart.js to render the visualizations.
+        
+        Args:
+            query_results: List of SQL query results to visualize
+        
+        Returns:
+            List of visualization specification dictionaries, or None if no
+            visualizations can be generated. Each dict contains:
+            - type: Chart type (bar, line, scatter, histogram)
+            - title: Display title
+            - x, y: Column names for axes
+            - data: The actual data to visualize
+        
+        Visualization selection logic:
+            - 2 columns: bar chart (categorical + numeric) or line chart (time series)
+            - 1 column: histogram (if numeric)
+            - 3+ columns: bar chart (first categorical + first numeric)
         """
         visualizations = []
         
         for i, qr in enumerate(query_results, 1):
+            # Skip queries that failed or returned no results
             if qr.error or len(qr.result) == 0:
                 continue
             

app/static/app.js

@@ -60,9 +60,6 @@ async function sendQuery() {
     return;
   }
   
-  // Check which approach to use
-  const approach = document.querySelector('input[name="approach"]:checked')?.value || 'sql';
-  
   // Show loading state
   const sendBtn = document.getElementById('send');
   const originalText = sendBtn.textContent;
@@ -70,10 +67,9 @@ async function sendQuery() {
   sendBtn.textContent = '⏳ שולח...';
   
   try {
-    let endpoint = approach === 'sql' ? '/query-sql' : '/query';
-    const body = approach === 'sql' 
-      ? { query: q, top_k: 5 }  // top_k not used in SQL approach but kept for compatibility
-      : { query: q, top_k: 100 };
+    // Always use SQL-based approach
+    let endpoint = '/query-sql';
+    const body = { query: q, top_k: 5 };
     
     const r = await fetch(endpoint, {
       method: 'POST', 
@@ -104,12 +100,9 @@ async function sendQuery() {
     const sourcesDiv = document.getElementById('resp-sources');
     
     if (showSources) {
-      if (approach === 'sql' && j.query_results && j.query_results.length > 0) {
+      if (j.query_results && j.query_results.length > 0) {
         sourcesDiv.style.display = 'block';
         sourcesDiv.innerHTML = formatSQLResults(j);
-      } else if (approach === 'rag' && j.results && j.results.length > 0) {
-        sourcesDiv.style.display = 'block';
-        sourcesDiv.innerHTML = formatSources(j.results);
       } else {
         if (sourcesDiv) sourcesDiv.style.display = 'none';
       }
@@ -117,8 +110,8 @@ async function sendQuery() {
       if (sourcesDiv) sourcesDiv.style.display = 'none';
     }
     
-    // Show visualizations if SQL approach and visualizations available
-    if (approach === 'sql' && j.visualizations && j.visualizations.length > 0) {
+    // Show visualizations if available
+    if (j.visualizations && j.visualizations.length > 0) {
       showVisualizations(j.visualizations);
     }
     
@@ -197,25 +190,56 @@ function showVisualizations(visualizations) {
   if (!vizContainer) {
     vizContainer = document.createElement('div');
     vizContainer.id = 'resp-visualizations';
-    vizContainer.style.marginTop = '20px';
+    vizContainer.className = 'viz-container';
+    vizContainer.style.marginTop = '24px';
     document.getElementById('last-response').appendChild(vizContainer);
   }
   
   // Clear previous visualizations
-  vizContainer.innerHTML = '<h4 style="color: #1976d2; margin-bottom: 12px;">📊 גרפיקות:</h4>';
+  vizContainer.innerHTML = '<h4 class="viz-title">📊 גרפיקות ויזואליזציות</h4>';
   vizContainer.style.display = 'block';
   
   visualizations.forEach((viz, idx) => {
     const vizDiv = document.createElement('div');
-    vizDiv.style.marginBottom = '24px';
-    vizDiv.style.padding = '16px';
-    vizDiv.style.background = '#f8f9fa';
-    vizDiv.style.borderRadius = '8px';
+    vizDiv.style.marginBottom = '32px';
+    vizDiv.style.padding = '20px';
+    vizDiv.style.background = 'linear-gradient(135deg, #ffffff 0%, #f8f9fa 100%)';
+    vizDiv.style.borderRadius = '16px';
+    vizDiv.style.boxShadow = '0 4px 16px rgba(0,0,0,0.08)';
+    vizDiv.style.border = '1px solid rgba(25, 118, 210, 0.1)';
+    
+    // Add explanation based on chart type
+    let explanation = '';
+    switch(viz.type) {
+      case 'bar':
+        explanation = '📊 <strong>גרף עמודות:</strong> מציג את הנתונים בצורה ויזואלית ברורה. כל עמודה מייצגת קטגוריה, והגובה שלה מייצג את הערך. זה עוזר להשוות בין קטגוריות שונות ולהבין את ההבדלים ביניהן.';
+        break;
+      case 'line':
+        explanation = '📈 <strong>גרף קו:</strong> מציג מגמות ושינויים לאורך זמן. הקו עולה כשיש עלייה בערכים ויורד כשיש ירידה. זה עוזר לזהות דפוסים, שינויים תקופתיים, ומגמות ארוכות טווח.';
+        break;
+      case 'scatter':
+        explanation = '🔵 <strong>גרף פיזור:</strong> מציג את הקשר בין שני משתנים. כל נקודה מייצגת תצפית אחת. זה עוזר לזהות קשרים, מתאמים, וחריגים בנתונים.';
+        break;
+      case 'histogram':
+        explanation = '📊 <strong>היסטוגרמה:</strong> מציגה את התפלגות הנתונים. כל עמודה מייצגת טווח ערכים, והגובה שלה מייצג כמה תצפיות נפלו בטווח הזה. זה עוזר להבין את הצורה של ההתפלגות - האם היא סימטרית, מוטה, או יש לה כמה פסגות.';
+        break;
+      default:
+        explanation = '📊 <strong>ויזואליזציה:</strong> מציגה את הנתונים בצורה גרפית כדי להקל על הבנה וניתוח.';
+    }
+    
+    vizDiv.innerHTML = `
+      <h5 style="margin-top: 0; color: #1976d2; font-size: 18px; font-weight: 700; margin-bottom: 16px;">
+        ${escapeHtml(viz.title)}
+      </h5>
+      <div class="viz-explanation">${explanation}</div>
+    `;
     
-    vizDiv.innerHTML = `<h5 style="margin-top: 0; color: #1976d2;">${escapeHtml(viz.title)}</h5>`;
     const canvasDiv = document.createElement('div');
     canvasDiv.style.position = 'relative';
-    canvasDiv.style.height = '300px';
+    canvasDiv.style.height = '350px';
+    canvasDiv.style.background = '#ffffff';
+    canvasDiv.style.borderRadius = '12px';
+    canvasDiv.style.padding = '16px';
     canvasDiv.innerHTML = `<canvas id="chart-${idx}"></canvas>`;
     vizDiv.appendChild(canvasDiv);
     
@@ -241,8 +265,20 @@ function getChartConfig(viz, idx) {
   const xLabel = viz.x_label || viz.x || 'X';
   const yLabel = viz.y_label || viz.y || 'Y';
   
+  // Color palettes for different chart types
+  const colorPalettes = {
+    bar: [
+      'rgba(25, 118, 210, 0.8)', 'rgba(76, 175, 80, 0.8)', 'rgba(255, 152, 0, 0.8)',
+      'rgba(156, 39, 176, 0.8)', 'rgba(244, 67, 54, 0.8)', 'rgba(0, 188, 212, 0.8)',
+      'rgba(255, 193, 7, 0.8)', 'rgba(121, 85, 72, 0.8)'
+    ],
+    line: ['rgba(25, 118, 210, 1)', 'rgba(76, 175, 80, 1)', 'rgba(255, 152, 0, 1)'],
+    scatter: ['rgba(25, 118, 210, 0.7)', 'rgba(76, 175, 80, 0.7)', 'rgba(255, 152, 0, 0.7)']
+  };
+  
   switch (viz.type) {
     case 'bar':
+      const barColors = viz.data.map((_, i) => colorPalettes.bar[i % colorPalettes.bar.length]);
       return {
         type: 'bar',
         data: {
@@ -250,9 +286,11 @@ function getChartConfig(viz, idx) {
           datasets: [{
             label: yLabel,
             data: viz.data.map(d => d[viz.y]),
-            backgroundColor: 'rgba(25, 118, 210, 0.6)',
-            borderColor: 'rgba(25, 118, 210, 1)',
-            borderWidth: 1
+            backgroundColor: barColors,
+            borderColor: barColors.map(c => c.replace('0.8', '1')),
+            borderWidth: 2,
+            borderRadius: 8,
+            borderSkipped: false,
           }]
         },
         options: {
@@ -261,10 +299,24 @@ function getChartConfig(viz, idx) {
           plugins: {
             legend: {
               display: true,
-              position: 'top'
+              position: 'top',
+              labels: {
+                font: { size: 14, weight: 'bold' },
+                padding: 15,
+                usePointStyle: true
+              }
             },
             title: {
               display: false
+            },
+            tooltip: {
+              backgroundColor: 'rgba(0, 0, 0, 0.8)',
+              padding: 12,
+              titleFont: { size: 14, weight: 'bold' },
+              bodyFont: { size: 13 },
+              borderColor: 'rgba(25, 118, 210, 0.8)',
+              borderWidth: 2,
+              cornerRadius: 8
             }
           },
           scales: {
@@ -272,13 +324,33 @@ function getChartConfig(viz, idx) {
               beginAtZero: true,
               title: {
                 display: true,
-                text: yLabel
+                text: yLabel,
+                font: { size: 14, weight: 'bold' },
+                color: '#1976d2'
+              },
+              grid: {
+                color: 'rgba(25, 118, 210, 0.1)',
+                lineWidth: 1
+              },
+              ticks: {
+                font: { size: 12 },
+                color: '#555'
               }
             },
             x: {
               title: {
                 display: true,
-                text: xLabel
+                text: xLabel,
+                font: { size: 14, weight: 'bold' },
+                color: '#1976d2'
+              },
+              grid: {
+                color: 'rgba(25, 118, 210, 0.1)',
+                lineWidth: 1
+              },
+              ticks: {
+                font: { size: 12 },
+                color: '#555'
               }
             }
           }
@@ -294,10 +366,18 @@ function getChartConfig(viz, idx) {
             label: yLabel,
             data: viz.data.map(d => d[viz.y]),
             borderColor: 'rgba(25, 118, 210, 1)',
-            backgroundColor: 'rgba(25, 118, 210, 0.1)',
-            borderWidth: 2,
+            backgroundColor: 'rgba(25, 118, 210, 0.15)',
+            borderWidth: 3,
             fill: true,
-            tension: 0.4
+            tension: 0.5,
+            pointRadius: 5,
+            pointHoverRadius: 7,
+            pointBackgroundColor: 'rgba(25, 118, 210, 1)',
+            pointBorderColor: '#ffffff',
+            pointBorderWidth: 2,
+            pointHoverBackgroundColor: 'rgba(25, 118, 210, 1)',
+            pointHoverBorderColor: '#ffffff',
+            pointHoverBorderWidth: 3
           }]
         },
         options: {
@@ -306,7 +386,21 @@ function getChartConfig(viz, idx) {
           plugins: {
             legend: {
               display: true,
-              position: 'top'
+              position: 'top',
+              labels: {
+                font: { size: 14, weight: 'bold' },
+                padding: 15,
+                usePointStyle: true
+              }
+            },
+            tooltip: {
+              backgroundColor: 'rgba(0, 0, 0, 0.8)',
+              padding: 12,
+              titleFont: { size: 14, weight: 'bold' },
+              bodyFont: { size: 13 },
+              borderColor: 'rgba(25, 118, 210, 0.8)',
+              borderWidth: 2,
+              cornerRadius: 8
             }
           },
           scales: {
@@ -314,13 +408,33 @@ function getChartConfig(viz, idx) {
               beginAtZero: true,
               title: {
                 display: true,
-                text: yLabel
+                text: yLabel,
+                font: { size: 14, weight: 'bold' },
+                color: '#1976d2'
+              },
+              grid: {
+                color: 'rgba(25, 118, 210, 0.1)',
+                lineWidth: 1
+              },
+              ticks: {
+                font: { size: 12 },
+                color: '#555'
               }
             },
             x: {
               title: {
                 display: true,
-                text: xLabel
+                text: xLabel,
+                font: { size: 14, weight: 'bold' },
+                color: '#1976d2'
+              },
+              grid: {
+                color: 'rgba(25, 118, 210, 0.1)',
+                lineWidth: 1
+              },
+              ticks: {
+                font: { size: 12 },
+                color: '#555'
               }
             }
           }
@@ -337,9 +451,14 @@ function getChartConfig(viz, idx) {
               x: d[viz.x],
               y: d[viz.y]
             })),
-            backgroundColor: 'rgba(25, 118, 210, 0.6)',
+            backgroundColor: 'rgba(25, 118, 210, 0.7)',
             borderColor: 'rgba(25, 118, 210, 1)',
-            borderWidth: 1
+            borderWidth: 2,
+            pointRadius: 6,
+            pointHoverRadius: 8,
+            pointHoverBackgroundColor: 'rgba(76, 175, 80, 0.8)',
+            pointHoverBorderColor: '#ffffff',
+            pointHoverBorderWidth: 2
           }]
         },
         options: {
@@ -348,7 +467,21 @@ function getChartConfig(viz, idx) {
           plugins: {
             legend: {
               display: true,
-              position: 'top'
+              position: 'top',
+              labels: {
+                font: { size: 14, weight: 'bold' },
+                padding: 15,
+                usePointStyle: true
+              }
+            },
+            tooltip: {
+              backgroundColor: 'rgba(0, 0, 0, 0.8)',
+              padding: 12,
+              titleFont: { size: 14, weight: 'bold' },
+              bodyFont: { size: 13 },
+              borderColor: 'rgba(25, 118, 210, 0.8)',
+              borderWidth: 2,
+              cornerRadius: 8
             }
           },
           scales: {
@@ -356,14 +489,34 @@ function getChartConfig(viz, idx) {
               beginAtZero: true,
               title: {
                 display: true,
-                text: yLabel
+                text: yLabel,
+                font: { size: 14, weight: 'bold' },
+                color: '#1976d2'
+              },
+              grid: {
+                color: 'rgba(25, 118, 210, 0.1)',
+                lineWidth: 1
+              },
+              ticks: {
+                font: { size: 12 },
+                color: '#555'
               }
             },
             x: {
               beginAtZero: true,
               title: {
                 display: true,
-                text: xLabel
+                text: xLabel,
+                font: { size: 14, weight: 'bold' },
+                color: '#1976d2'
+              },
+              grid: {
+                color: 'rgba(25, 118, 210, 0.1)',
+                lineWidth: 1
+              },
+              ticks: {
+                font: { size: 12 },
+                color: '#555'
               }
             }
           }
@@ -392,6 +545,11 @@ function getChartConfig(viz, idx) {
         bins[binIndex]++;
       });
       
+      const histColors = bins.map((_, i) => {
+        const ratio = i / binCount;
+        return `rgba(${25 + Math.floor(ratio * 180)}, ${118 + Math.floor(ratio * 100)}, ${210 - Math.floor(ratio * 100)}, 0.8)`;
+      });
+      
       return {
         type: 'bar',
         data: {
@@ -399,9 +557,11 @@ function getChartConfig(viz, idx) {
           datasets: [{
             label: xLabel,
             data: bins,
-            backgroundColor: 'rgba(25, 118, 210, 0.6)',
-            borderColor: 'rgba(25, 118, 210, 1)',
-            borderWidth: 1
+            backgroundColor: histColors,
+            borderColor: histColors.map(c => c.replace('0.8', '1')),
+            borderWidth: 2,
+            borderRadius: 4,
+            borderSkipped: false,
           }]
         },
         options: {
@@ -410,7 +570,21 @@ function getChartConfig(viz, idx) {
           plugins: {
             legend: {
               display: true,
-              position: 'top'
+              position: 'top',
+              labels: {
+                font: { size: 14, weight: 'bold' },
+                padding: 15,
+                usePointStyle: true
+              }
+            },
+            tooltip: {
+              backgroundColor: 'rgba(0, 0, 0, 0.8)',
+              padding: 12,
+              titleFont: { size: 14, weight: 'bold' },
+              bodyFont: { size: 13 },
+              borderColor: 'rgba(25, 118, 210, 0.8)',
+              borderWidth: 2,
+              cornerRadius: 8
             }
           },
           scales: {
@@ -418,13 +592,33 @@ function getChartConfig(viz, idx) {
               beginAtZero: true,
               title: {
                 display: true,
-                text: 'תדירות'
+                text: 'תדירות',
+                font: { size: 14, weight: 'bold' },
+                color: '#1976d2'
+              },
+              grid: {
+                color: 'rgba(25, 118, 210, 0.1)',
+                lineWidth: 1
+              },
+              ticks: {
+                font: { size: 12 },
+                color: '#555'
               }
             },
             x: {
               title: {
                 display: true,
-                text: xLabel
+                text: xLabel,
+                font: { size: 14, weight: 'bold' },
+                color: '#1976d2'
+              },
+              grid: {
+                color: 'rgba(25, 118, 210, 0.1)',
+                lineWidth: 1
+              },
+              ticks: {
+                font: { size: 12 },
+                color: '#555'
               }
             }
           }
@@ -450,21 +644,7 @@ function formatResponse(text) {
   return formatted;
 }
 
-function formatSources(results) {
-  if (!results || results.length === 0) return '';
-  let html = '<h4 style="margin-top: 20px; color: #1976d2;">דוגמאות מהנתונים:</h4>';
-  results.slice(0, 5).forEach((r, idx) => {
-    html += `
-      <div style="margin: 12px 0; padding: 12px; background: #f5f5f5; border-radius: 8px; border-right: 4px solid #1976d2;">
-        <div style="font-size: 12px; color: #666; margin-bottom: 4px;">
-          דוגמה ${idx + 1} | שירות: ${escapeHtml(r.service || 'N/A')} | ציון: ${r.level || 'N/A'} | דמיון: ${(r.score * 100).toFixed(1)}%
-        </div>
-        <div style="color: #333;">${escapeHtml(r.text || '').substring(0, 300)}${r.text && r.text.length > 300 ? '...' : ''}</div>
-      </div>
-    `;
-  });
-  return html;
-}
+// formatSources function removed - no longer needed (RAG approach deprecated)
 
 async function clearHistory() {
   try {

app/static/index.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>Feedback RAG — Frontend</title>
+  <title>Feedback Analysis — Frontend</title>
   <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
   <style>
     * { box-sizing: border-box; }
@@ -11,7 +11,7 @@
       font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Noto Sans Hebrew', 'Arial Hebrew', sans-serif; 
       margin: 0; 
       direction: rtl; 
-      background: linear-gradient(135deg, #4caf50 0%, #388e3c 50%, #2e7d32 100%); 
+      background: linear-gradient(135deg, #1976d2 0%, #1565c0 50%, #0d47a1 100%); 
       min-height: 100vh; 
       color: #0b2545; 
       padding-bottom: 40px;
@@ -105,27 +105,57 @@
       transform: translateY(-2px);
     }
     .card { 
-      border-radius: 16px; 
-      padding: 24px; 
-      margin-top: 20px; 
-      background: white; 
-      box-shadow: 0 10px 40px rgba(0,0,0,0.15); 
-      transition: transform 0.2s, box-shadow 0.2s;
+      border-radius: 20px; 
+      padding: 28px; 
+      margin-top: 24px; 
+      background: linear-gradient(135deg, #ffffff 0%, #f8f9fa 100%); 
+      box-shadow: 0 12px 48px rgba(0,0,0,0.12), 0 4px 16px rgba(0,0,0,0.08); 
+      transition: transform 0.3s ease, box-shadow 0.3s ease;
+      border: 1px solid rgba(255,255,255,0.8);
     }
     .card:hover {
-      transform: translateY(-2px);
-      box-shadow: 0 12px 50px rgba(0,0,0,0.2);
+      transform: translateY(-4px);
+      box-shadow: 0 16px 64px rgba(0,0,0,0.18), 0 6px 24px rgba(0,0,0,0.12);
     }
     .summary { 
       font-size: 17px; 
-      line-height: 1.8; 
+      line-height: 1.9; 
       color: #073763; 
       white-space: pre-wrap; 
       word-wrap: break-word; 
-      background: #f8f9fa;
-      padding: 20px;
+      background: linear-gradient(135deg, #f8f9fa 0%, #ffffff 100%);
+      padding: 24px;
+      border-radius: 16px;
+      border-right: 5px solid #1976d2;
+      box-shadow: inset 0 2px 8px rgba(0,0,0,0.05);
+    }
+    .viz-container {
+      background: linear-gradient(135deg, #ffffff 0%, #f0f7ff 100%);
+      border-radius: 16px;
+      padding: 24px;
+      margin-top: 24px;
+      box-shadow: 0 8px 32px rgba(25, 118, 210, 0.1);
+      border: 2px solid rgba(25, 118, 210, 0.15);
+    }
+    .viz-explanation {
+      background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%);
+      padding: 16px 20px;
       border-radius: 12px;
+      margin-bottom: 20px;
       border-right: 4px solid #1976d2;
+      color: #0d47a1;
+      font-size: 15px;
+      line-height: 1.7;
+      box-shadow: 0 2px 8px rgba(25, 118, 210, 0.15);
+    }
+    .viz-title {
+      color: #1976d2;
+      font-size: 20px;
+      font-weight: 700;
+      margin-bottom: 16px;
+      display: flex;
+      align-items: center;
+      gap: 8px;
     }
     .result { white-space: pre-wrap; }
     header .title { font-size: 20px; margin:0 }
@@ -193,8 +223,12 @@
 <body>
   <div class="container">
     <header>
-      <h1>Feedback RAG — ממשק</h1>
-      <div class="small">שרת: <span id="server-status">...בדיקה</span></div>
+      <h1>Feedback Analysis — ממשק</h1>
+      <div style="display: flex; gap: 16px; align-items: center;">
+        <div class="small">שרת: <span id="server-status">...בדיקה</span></div>
+        <a href="https://github.com" target="_blank" style="color: white; text-decoration: none; font-size: 14px; padding: 6px 12px; background: rgba(255,255,255,0.2); border-radius: 6px; transition: all 0.2s;">🔗 GitHub</a>
+        <a href="https://ynet.co.il" target="_blank" style="color: white; text-decoration: none; font-size: 14px; padding: 6px 12px; background: rgba(255,255,255,0.2); border-radius: 6px; transition: all 0.2s;">📄 קורות חיים</a>
+      </div>
     </header>
 
     <section class="card">
@@ -204,13 +238,6 @@
         <label><input type="checkbox" id="show-sources" /> הצג דוגמאות מהנתונים</label>
         <span class="small" style="margin-left:12px;">ברירת מחדל: מוסתר — יוצג רק הסיכום האנליטי</span>
       </div>
-      <div style="margin-top:12px;">
-        <label style="font-weight: 600;">גישת ניתוח:</label>
-        <div style="margin-top:8px;">
-          <label><input type="radio" name="approach" value="sql" checked /> SQL-based (מומלץ - חדש)</label>
-          <label style="margin-right:20px;"><input type="radio" name="approach" value="rag" /> RAG-based (ישן)</label>
-        </div>
-      </div>
       <div style="display:flex;gap:8px;margin-top:12px;">
         <button id="send" class="primary">🔍 שאל</button>
         <button id="clear-history" class="muted">🗑️ נקה היסטוריה</button>

app/topics.py

@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import List, Dict
-
-import numpy as np
-from sklearn.cluster import KMeans  # type: ignore
-
-
-@dataclass
-class TopicResult:
-    labels: List[int]
-    centroids: np.ndarray
-
-
-def kmeans_topics(embeddings: np.ndarray, num_topics: int = 8, seed: int = 42) -> TopicResult:
-    if len(embeddings) == 0:
-        return TopicResult(labels=[], centroids=np.empty((0, embeddings.shape[1])))
-    km = KMeans(n_clusters=num_topics, random_state=seed, n_init="auto")
-    labels = km.fit_predict(embeddings)
-    return TopicResult(labels=list(map(int, labels)), centroids=km.cluster_centers_) 
-

app/vector_store.py

@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-"""A thin wrapper around FAISS index and a Pandas DataFrame for metadata.
-
-FaissVectorStore provides methods to add vectors, perform nearest-neighbor search,
-and persist both the FAISS index and the accompanying metadata (as a parquet file).
-
-SearchResult holds the matched index, similarity score and the original metadata row.
-"""
-
-import os
-from dataclasses import dataclass
-from typing import List, Tuple, Optional
-
-import faiss  # type: ignore
-import numpy as np
-import pandas as pd
-
-from .config import settings
-
-
-@dataclass
-class SearchResult:
-    index: int
-    score: float
-    row: pd.Series
-
-
-class FaissVectorStore:
-    def __init__(self, dim: int) -> None:
-        self.dim = dim
-        self.index = faiss.IndexFlatIP(dim)
-        self.metadata: Optional[pd.DataFrame] = None
-
-    def add(self, vectors: np.ndarray, metadata: pd.DataFrame) -> None:
-        if vectors.dtype != np.float32:
-            vectors = vectors.astype(np.float32)
-        if self.metadata is None:
-            self.metadata = metadata.reset_index(drop=True)
-        else:
-            self.metadata = pd.concat([self.metadata, metadata], ignore_index=True)
-        self.index.add(vectors)
-
-    def search(self, query_vector: np.ndarray, top_k: int = 5) -> List[SearchResult]:
-        q = query_vector.astype(np.float32).reshape(1, -1)
-        scores, idxs = self.index.search(q, top_k)
-        results: List[SearchResult] = []
-        for score, idx in zip(scores[0], idxs[0]):
-            if idx < 0 or self.metadata is None:
-                continue
-            results.append(SearchResult(index=int(idx), score=float(score), row=self.metadata.iloc[int(idx)]))
-        return results
-
-    def save(self, vector_path: str, meta_path: str) -> None:
-        os.makedirs(os.path.dirname(vector_path), exist_ok=True)
-        faiss.write_index(self.index, vector_path)
-        if self.metadata is not None:
-            self.metadata.to_parquet(meta_path, index=False)
-
-    @classmethod
-    def load(cls, vector_path: str, meta_path: str) -> "FaissVectorStore":
-        index = faiss.read_index(vector_path)
-        dim = index.d
-        store = cls(dim=dim)
-        store.index = index
-        if os.path.exists(meta_path):
-            store.metadata = pd.read_parquet(meta_path)
-        return store
-

requirements.txt

@@ -1,20 +1,15 @@
+# Core dependencies
 fastapi==0.115.5
 uvicorn[standard]==0.32.0
 pandas==2.2.3
 numpy==1.26.4
-scikit-learn==1.5.2
-faiss-cpu==1.8.0.post1
-sentence-transformers==3.1.1
-transformers==4.45.2
-torch==2.4.1
-langdetect==1.0.9
-openai==1.52.2
 python-dotenv==1.0.1
 pydantic==2.9.2
 orjson==3.10.7
+
+# LLM providers (at least one required)
+openai==1.52.2
 google-generativeai==0.6.0
-pyarrow==14.0.2
-tiktoken==0.7.0
 
 # Dev / test dependencies
 pytest==7.4.0

scripts/precompute_index.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-"""Script to precompute the FAISS vector index locally.
-
-When deploying to Runpod it's often useful to precompute embeddings and store
-the FAISS index so the server can start quickly without re-embedding the
-entire dataset on first boot. This script writes the index and metadata to
-the configured `VECTOR_INDEX_PATH` and `VECTOR_METADATA_PATH`.
-"""
-
-import os
-from pathlib import Path
-
-from app.rag_service import RAGService
-from app.config import settings
-
-
-def main() -> None:
-    out_dir = Path(settings.vector_index_path).parent
-    out_dir.mkdir(parents=True, exist_ok=True)
-    svc = RAGService()
-    svc.ingest()
-    print(f"Index written to: {settings.vector_index_path}")
-    print(f"Metadata written to: {settings.vector_metadata_path}")
-
-
-if __name__ == "__main__":
-    main()
-

scripts/smoke_check.py

@@ -16,8 +16,9 @@ def get_root() -> str:
 
 
 def post_query(q: str):
+    """Test SQL-based query endpoint."""
     data = json.dumps({"query": q, "top_k": 5}).encode("utf-8")
-    req = urllib.request.Request("http://127.0.0.1:8000/query", data=data, headers={"Content-Type": "application/json"})
+    req = urllib.request.Request("http://127.0.0.1:8000/query-sql", data=data, headers={"Content-Type": "application/json"})
     with urllib.request.urlopen(req, timeout=30) as resp:
         return json.load(resp)
 
@@ -32,13 +33,15 @@ def main() -> None:
         return
 
     sample_q = "מה הבעיות העיקריות שמשתמשים מציינים?"
-    print("Posting sample query to /query ...")
+    print("Posting sample query to /query-sql ...")
     try:
         resp = post_query(sample_q)
         print("Query response keys:", list(resp.keys()))
         print("Summary (truncated):\n", (resp.get("summary") or "(no summary)")[:800])
+        if resp.get("sql_queries"):
+            print(f"Generated {len(resp['sql_queries'])} SQL queries")
     except Exception as e:
-        print("Failed to POST /query:", e)
+        print("Failed to POST /query-sql:", e)
 
 
 if __name__ == "__main__":

scripts/test_queries.py

@@ -1,48 +0,0 @@
-"""Small harness to demonstrate query type detection and quick counts.
-
-This script intentionally keeps heavy dependencies optional: it runs the
-lightweight count logic (keyword-based) directly from the CSV. If the FAISS
-index and embedding dependencies are available, it will also show example
-contexts from semantic retrieval.
-"""
-
-from __future__ import annotations
-
-from app.data_loader import load_feedback
-from app.analysis import detect_query_type, resolve_count_from_type
-
-
-def run_examples():
-    examples = [
-        "כמה משתמשים מתלוננים על אלמנטים שלא עובדים להם במערכת",
-        "כמה משתמשים כתבו תודה",
-        "יש תקלות בשירות ההרשמה",
-        "מה הבעיות העיקריות שמשתמשים מציינים?",
-    ]
-
-    df = load_feedback()
-
-    for q in examples:
-        print("\nQuery:", q)
-        qtype, target = detect_query_type(q)
-        print("Detected type:", qtype, "target:", target)
-        resolved = resolve_count_from_type(df, qtype, target)
-        if resolved.get("type") == "count":
-            print("Count result:", resolved.get("count"), resolved.get("label"))
-        else:
-            # Fallback to semantic answer (may require heavy deps and a built index). Try to import and run if available.
-            try:
-                from app.rag_service import RAGService
-                svc = RAGService()
-                out = svc.answer(q, top_k=3)
-                print("Summary:", out.summary)
-                for r in out.results:
-                    print(f"- [{r.score:.3f}] {r.row.get('ServiceName','')} | {r.row.get('Text','')[:120]}")
-            except FileNotFoundError:
-                print("Vector index not found. Run /ingest or precompute index to see examples.")
-            except Exception as e:
-                print("Semantic retrieval unavailable (missing packages or other error):", e)
-
-
-if __name__ == "__main__":
-    run_examples()

scripts/validate_local.py

@@ -1,314 +0,0 @@
-"""Complete validation and testing harness for local development.
-
-This script:
-1. Checks dependencies
-2. Validates the CSV and index
-3. Tests all API endpoints
-4. Provides clear pass/fail feedback
-
-Run this BEFORE testing manually to ensure everything works correctly.
-"""
-
-from __future__ import annotations
-
-import sys
-import time
-from pathlib import Path
-
-# Color codes for terminal output
-GREEN = "\033[92m"
-RED = "\033[91m"
-YELLOW = "\033[93m"
-BLUE = "\033[94m"
-RESET = "\033[0m"
-
-
-def print_status(message: str, status: str = "INFO") -> None:
-    """Print colored status messages."""
-    colors = {
-        "PASS": GREEN,
-        "FAIL": RED,
-        "WARN": YELLOW,
-        "INFO": BLUE,
-    }
-    color = colors.get(status, RESET)
-    print(f"{color}[{status}]{RESET} {message}")
-
-
-def check_dependencies() -> bool:
-    """Verify all required packages are installed."""
-    print_status("Checking dependencies...", "INFO")
-    required = [
-        ("pandas", "pandas"),
-        ("fastapi", "fastapi"),
-        ("pydantic", "pydantic"),
-        ("sentence_transformers", "sentence_transformers"),
-        ("transformers", "transformers"),
-        ("faiss", "faiss"),
-        ("numpy", "numpy"),
-    ]
-    
-    missing = []
-    for pkg_name, import_name in required:
-        try:
-            __import__(import_name)
-            print_status(f"✓ {pkg_name}", "PASS")
-        except ImportError:
-            print_status(f"✗ {pkg_name} NOT FOUND", "FAIL")
-            missing.append(pkg_name)
-    
-    if missing:
-        print_status(
-            f"Missing packages: {', '.join(missing)}. "
-            "Run: pip install -r requirements.txt",
-            "FAIL"
-        )
-        return False
-    return True
-
-
-def check_csv() -> bool:
-    """Verify CSV exists and has required columns."""
-    print_status("Checking CSV...", "INFO")
-    csv_path = Path("Feedback.csv")
-    
-    if not csv_path.exists():
-        print_status(f"CSV not found at {csv_path}", "FAIL")
-        return False
-    
-    try:
-        import pandas as pd
-        df = pd.read_csv(csv_path)
-        required_cols = ["ID", "ServiceName", "Level", "Text"]
-        missing_cols = [c for c in required_cols if c not in df.columns]
-        
-        if missing_cols:
-            print_status(f"Missing columns: {missing_cols}", "FAIL")
-            return False
-        
-        print_status(f"✓ CSV valid: {len(df)} rows, {len(df.columns)} columns", "PASS")
-        return True
-    except Exception as e:
-        print_status(f"Error reading CSV: {e}", "FAIL")
-        return False
-
-
-def check_index() -> bool:
-    """Verify FAISS index is precomputed."""
-    print_status("Checking FAISS index...", "INFO")
-    
-    index_path = Path(".vector_index/faiss.index")
-    meta_path = Path(".vector_index/meta.parquet")
-    
-    if not index_path.exists():
-        print_status(
-            f"Index not found at {index_path}. "
-            "Run: python scripts/precompute_index.py",
-            "WARN"
-        )
-        return False
-    
-    if not meta_path.exists():
-        print_status(f"Metadata not found at {meta_path}", "FAIL")
-        return False
-    
-    try:
-        index_size = index_path.stat().st_size / (1024 * 1024)  # MB
-        print_status(f"✓ Index found ({index_size:.1f} MB)", "PASS")
-        return True
-    except Exception as e:
-        print_status(f"Error checking index: {e}", "FAIL")
-        return False
-
-
-def test_imports() -> bool:
-    """Test that all app modules import correctly."""
-    print_status("Testing app imports...", "INFO")
-    
-    try:
-        from app.config import settings
-        from app.data_loader import load_feedback
-        from app.analysis import detect_query_type, resolve_count_from_type
-        from app.rag_service import RAGService
-        from app.api import app
-        
-        print_status("✓ All imports successful", "PASS")
-        return True
-    except Exception as e:
-        print_status(f"Import error: {e}", "FAIL")
-        return False
-
-
-def test_analysis_logic() -> bool:
-    """Test query analysis and counting logic (no embeddings needed)."""
-    print_status("Testing analysis logic (lightweight)...", "INFO")
-    
-    try:
-        from app.data_loader import load_feedback
-        from app.analysis import detect_query_type, resolve_count_from_type
-        
-        df = load_feedback()
-        
-        # Test 1: Count thanks
-        qtype, target = detect_query_type("כמה משתמשים כתבו תודה")
-        result = resolve_count_from_type(df, qtype, target)
-        assert result["type"] == "count"
-        thanks_count = result["count"]
-        print_status(f"✓ Thanks count: {thanks_count}", "PASS")
-        
-        # Test 2: Count complaints
-        qtype, target = detect_query_type("כמה משתמשים מתלוננים על אלמנטים שלא עובדים")
-        result = resolve_count_from_type(df, qtype, target)
-        assert result["type"] == "count"
-        complaint_count = result["count"]
-        print_status(f"✓ Complaint count: {complaint_count}", "PASS")
-        
-        return True
-    except Exception as e:
-        print_status(f"Analysis test error: {e}", "FAIL")
-        return False
-
-
-def test_rag_service() -> bool:
-    """Test RAGService with precomputed index."""
-    print_status("Testing RAGService...", "INFO")
-    
-    try:
-        from app.rag_service import RAGService
-        
-        svc = RAGService()
-        print_status("✓ RAGService initialized", "PASS")
-        
-        # Test query (should use precomputed index)
-        result = svc.answer("כמה משתמשים כתבו תודה", top_k=3)
-        
-        if result.summary:
-            print_status(f"✓ Query response: {result.summary[:60]}...", "PASS")
-        else:
-            print_status("Query returned empty summary", "WARN")
-        
-        if result.results:
-            print_status(f"✓ Retrieved {len(result.results)} results", "PASS")
-        else:
-            print_status("No results retrieved (may be expected if index small)", "WARN")
-        
-        return True
-    except Exception as e:
-        print_status(f"RAGService error: {e}", "FAIL")
-        return False
-
-
-def test_api_endpoints() -> bool:
-    """Test FastAPI endpoints locally."""
-    print_status("Testing API endpoints...", "INFO")
-    
-    try:
-        from fastapi.testclient import TestClient
-        from app.api import app
-        
-        client = TestClient(app)
-        
-        # Test /health
-        resp = client.post("/health")
-        assert resp.status_code == 200, f"Health check failed: {resp.status_code}"
-        print_status("✓ POST /health works", "PASS")
-        
-        # Test /query
-        resp = client.post("/query", json={"query": "כמה משתמשים כתבו תודה", "top_k": 3})
-        assert resp.status_code == 200, f"Query failed: {resp.status_code}"
-        data = resp.json()
-        assert "summary" in data, "Query response missing summary"
-        print_status(f"✓ POST /query works (summary: {data['summary'][:50]}...)", "PASS")
-        
-        # Test /topics
-        resp = client.post("/topics", json={"num_topics": 3})
-        assert resp.status_code == 200, f"Topics failed: {resp.status_code}"
-        data = resp.json()
-        assert "topics" in data, "Topics response missing topics"
-        print_status(f"✓ POST /topics works ({len(data.get('topics', {}))} topics)", "PASS")
-        
-        # Test /sentiment
-        resp = client.post("/sentiment", json={"limit": 50})
-        assert resp.status_code == 200, f"Sentiment failed: {resp.status_code}"
-        data = resp.json()
-        assert "results" in data, "Sentiment response missing results"
-        print_status(f"✓ POST /sentiment works ({data['count']} results)", "PASS")
-        
-        # Test /ingest (will try to rebuild index)
-        print_status("Testing /ingest (will rebuild index)...", "WARN")
-        start = time.time()
-        resp = client.post("/ingest")
-        elapsed = time.time() - start
-        assert resp.status_code == 200, f"Ingest failed: {resp.status_code}"
-        print_status(f"✓ POST /ingest works (took {elapsed:.1f}s)", "PASS")
-        
-        return True
-    except Exception as e:
-        print_status(f"API test error: {e}", "FAIL")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def main() -> None:
-    """Run all validations."""
-    print(f"\n{BLUE}{'='*60}")
-    print("FEEDBACK ANALYSIS RAG AGENT - LOCAL VALIDATION")
-    print(f"{'='*60}{RESET}\n")
-    
-    checks = [
-        ("Dependencies", check_dependencies),
-        ("CSV file", check_csv),
-        ("FAISS Index", check_index),
-        ("App imports", test_imports),
-        ("Analysis logic", test_analysis_logic),
-        ("RAGService", test_rag_service),
-        ("API endpoints", test_api_endpoints),
-    ]
-    
-    results = []
-    for name, check_func in checks:
-        print(f"\n{name}:")
-        print("-" * 60)
-        try:
-            passed = check_func()
-            results.append((name, passed))
-        except Exception as e:
-            print_status(f"Unexpected error: {e}", "FAIL")
-            results.append((name, False))
-            import traceback
-            traceback.print_exc()
-    
-    # Summary
-    print(f"\n{BLUE}{'='*60}")
-    print("VALIDATION SUMMARY")
-    print(f"{'='*60}{RESET}\n")
-    
-    passed_count = sum(1 for _, p in results if p)
-    total_count = len(results)
-    
-    for name, passed in results:
-        status = "PASS" if passed else "FAIL"
-        color = GREEN if passed else RED
-        print(f"{color}[{status}]{RESET} {name}")
-    
-    print(f"\n{'-'*60}")
-    if passed_count == total_count:
-        print_status(f"All {total_count} checks PASSED! Ready for local testing.", "PASS")
-        print("\nNext steps:")
-        print("  1. Run: python run.py")
-        print("  2. Open: http://localhost:8000/docs")
-        print("  3. Or use curl (see QUICK_START.md)")
-        sys.exit(0)
-    else:
-        print_status(
-            f"{passed_count}/{total_count} checks passed. "
-            f"{total_count - passed_count} checks FAILED.",
-            "FAIL"
-        )
-        print("\nPlease fix the errors above before testing.")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()