יצירת גישה חדשה SQL-based: SQL query generator, executor, response synthesizer, API endpoint, ו-frontend support

.query_history.json

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

app/api.py

@@ -15,6 +15,7 @@ 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
@@ -22,6 +23,7 @@ from .vector_store import FaissVectorStore
 
 app = FastAPI(title="Feedback Analysis RAG Agent", version="1.0.0", default_response_class=ORJSONResponse)
 svc = RAGService()
+sql_svc = SQLFeedbackService()  # SQL-based service
 embedder = svc.embedder
 
 # Simple in-memory history persisted best-effort to `.query_history.json`
@@ -55,6 +57,14 @@ class QueryResponse(BaseModel):
     results: Optional[List[Dict[str, Any]]] = None  # Optional results for frontend
 
 
+class SQLQueryResponse(BaseModel):
+    query: str
+    summary: str
+    sql_queries: List[str]
+    query_results: List[Dict[str, Any]]  # Results of SQL queries
+    visualizations: Optional[List[Dict[str, Any]]] = None
+
+
 @app.post("/health")
 def health() -> Dict[str, str]:
     """Healthcheck endpoint.
@@ -64,6 +74,49 @@ def health() -> Dict[str, str]:
     return {"status": "ok"}
 
 
+@app.post("/query-sql", response_model=SQLQueryResponse)
+def query_sql(req: QueryRequest) -> SQLQueryResponse:
+    """SQL-based question answering over feedback data.
+    
+    This endpoint uses a SQL-based approach:
+    1. LLM generates 1-5 SQL queries
+    2. Executes queries on feedback data
+    3. LLM synthesizes comprehensive answer
+    4. Returns answer with query results and visualizations
+    """
+    try:
+        result = sql_svc.analyze_query(req.query)
+        
+        # Convert query results to JSON-serializable format
+        query_results = []
+        for qr in result.query_results:
+            query_results.append({
+                "query": qr.query,
+                "result": qr.result.to_dict('records') if not qr.error else [],
+                "error": qr.error,
+                "row_count": len(qr.result) if not qr.error else 0
+            })
+        
+        return SQLQueryResponse(
+            query=result.user_query,
+            summary=result.summary,
+            sql_queries=result.sql_queries,
+            query_results=query_results,
+            visualizations=result.visualizations
+        )
+    except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"Error in /query-sql endpoint: {error_details}", flush=True)
+        return SQLQueryResponse(
+            query=req.query,
+            summary=f"שגיאה: {str(e)}. אנא בדוק את הלוגים לפרטים נוספים.",
+            sql_queries=[],
+            query_results=[],
+            visualizations=None
+        )
+
+
 @app.post("/ingest")
 def ingest() -> Dict[str, Any]:
     """Build the vector index from Feedback.csv"""

app/sql_service.py

@@ -0,0 +1,375 @@
+"""
+SQL-based Feedback Analysis Service
+
+This module implements a SQL-based approach to analyzing feedback:
+1. LLM analyzes user query
+2. LLM generates 1-5 SQL queries to answer the question
+3. Execute SQL queries on the feedback DataFrame
+4. LLM synthesizes a comprehensive answer from query + SQL queries + results
+5. (Optional) Generate visualizations of the results
+"""
+
+from __future__ import annotations
+
+import json
+import re
+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
+
+try:
+    from openai import OpenAI  # type: ignore
+except Exception:
+    OpenAI = None
+
+try:
+    import google.generativeai as genai  # type: ignore
+except Exception:
+    genai = None
+
+
+@dataclass
+class SQLQueryResult:
+    """Result of a single SQL query execution."""
+    query: str
+    result: pd.DataFrame
+    error: Optional[str] = None
+
+
+@dataclass
+class AnalysisResult:
+    """Complete analysis result."""
+    user_query: str
+    sql_queries: List[str]
+    query_results: List[SQLQueryResult]
+    summary: str
+    visualizations: Optional[List[Dict[str, Any]]] = None
+
+
+class SQLFeedbackService:
+    """Service for SQL-based feedback analysis."""
+    
+    def __init__(self):
+        self.df: Optional[pd.DataFrame] = None
+        self._load_data()
+    
+    def _load_data(self):
+        """Load feedback data into memory."""
+        try:
+            self.df = load_feedback()
+            print(f"Loaded {len(self.df)} feedback records", flush=True)
+        except Exception as e:
+            print(f"Error loading feedback data: {e}", flush=True)
+            self.df = None
+    
+    def _get_schema_info(self) -> str:
+        """Get schema information for the feedback table."""
+        if self.df is None:
+            return "No data available"
+        
+        schema_info = f"""
+טבלת Feedback מכילה את השדות הבאים:
+- ID: מזהה ייחודי של כל משוב (מספר שלם)
+- ServiceName: שם השירות הדיגיטלי (טקסט)
+- Level: הציון שהמשתמש נתן לשירות (מספר שלם מ-1 עד 5, כאשר 1=גרוע, 5=מעולה)
+- Text: הטקסט החופשי שהמשתמש הזין כחלק מהפידבק (טקסט)
+
+סטטיסטיקות כלליות:
+- סך הכל משובים: {len(self.df)}
+- מספר שירותים ייחודיים: {self.df['ServiceName'].nunique()}
+- חלוקת דירוגים: {dict(self.df['Level'].value_counts().sort_index())}
+- דירוג ממוצע: {self.df['Level'].mean():.2f}
+"""
+        return schema_info
+    
+    def analyze_query(self, query: str) -> AnalysisResult:
+        """
+        Main analysis pipeline:
+        1. Analyze user query
+        2. Generate SQL queries
+        3. Execute SQL queries
+        4. Synthesize answer
+        """
+        if self.df is None:
+            raise ValueError("No feedback data available. Please ensure Feedback.csv exists.")
+        
+        # Step 1: Generate SQL queries
+        sql_queries = self._generate_sql_queries(query)
+        
+        # Step 2: Execute SQL queries
+        query_results = self._execute_sql_queries(sql_queries)
+        
+        # Step 3: Synthesize answer
+        summary = self._synthesize_answer(query, sql_queries, query_results)
+        
+        # Step 4: (Optional) Generate visualizations
+        visualizations = self._generate_visualizations(query_results)
+        
+        return AnalysisResult(
+            user_query=query,
+            sql_queries=sql_queries,
+            query_results=query_results,
+            summary=summary,
+            visualizations=visualizations
+        )
+    
+    def _generate_sql_queries(self, query: str) -> List[str]:
+        """
+        Use LLM to generate 1-5 SQL queries that will help answer the user's question.
+        """
+        schema_info = self._get_schema_info()
+        
+        prompt = f"""אתה אנליסט נתונים מומחה. המשתמש שאל שאלה על משובי משתמשים.
+
+שאלת המשתמש: {query}
+
+מידע על הטבלה:
+{schema_info}
+
+המשימה שלך: צור 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
+
+פורמט התשובה - JSON בלבד:
+{{
+  "queries": [
+    "SELECT ...",
+    "SELECT ...",
+    ...
+  ]
+}}
+
+תן רק את ה-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-1.5-flash")
+                response = model.generate_content(prompt)
+                text = getattr(response, "text", None)
+                if text:
+                    return self._parse_sql_queries(text)
+            except Exception as e:
+                print(f"Gemini error in SQL generation: {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": prompt}],
+                    temperature=0.3,
+                )
+                text = response.choices[0].message.content
+                if text:
+                    return self._parse_sql_queries(text)
+            except Exception as e:
+                print(f"OpenAI error in SQL generation: {e}", flush=True)
+        
+        # Fallback: return empty list
+        return []
+    
+    def _parse_sql_queries(self, text: str) -> List[str]:
+        """Parse SQL queries from LLM response."""
+        # Try to extract JSON
+        try:
+            # Remove markdown code blocks if present
+            text = re.sub(r'```json\s*', '', text)
+            text = re.sub(r'```\s*', '', text)
+            text = text.strip()
+            
+            # Try to parse as JSON
+            data = json.loads(text)
+            if isinstance(data, dict) and "queries" in data:
+                queries = data["queries"]
+                if isinstance(queries, list):
+                    return [q for q in queries if isinstance(q, str) and q.strip()]
+        except Exception:
+            pass
+        
+        # Fallback: try to extract SQL queries directly
+        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]
+        
+        return []
+    
+    def _execute_sql_queries(self, sql_queries: List[str]) -> List[SQLQueryResult]:
+        """Execute SQL queries on the feedback DataFrame."""
+        if self.df is None:
+            return []
+        
+        results = []
+        
+        # Create in-memory SQLite database
+        conn = sqlite3.connect(':memory:')
+        try:
+            # Write DataFrame to SQLite
+            self.df.to_sql('feedback', conn, index=False, if_exists='replace')
+            
+            for query in sql_queries:
+                try:
+                    # Execute query
+                    result_df = pd.read_sql_query(query, conn)
+                    results.append(SQLQueryResult(
+                        query=query,
+                        result=result_df,
+                        error=None
+                    ))
+                except Exception as e:
+                    results.append(SQLQueryResult(
+                        query=query,
+                        result=pd.DataFrame(),
+                        error=str(e)
+                    ))
+        finally:
+            conn.close()
+        
+        return results
+    
+    def _synthesize_answer(self, query: str, sql_queries: List[str], 
+                          query_results: List[SQLQueryResult]) -> str:
+        """
+        Use LLM to synthesize a comprehensive answer from:
+        - User query
+        - SQL queries that were executed
+        - Results of those queries
+        """
+        # Format query results for the prompt
+        results_text = ""
+        for i, qr in enumerate(query_results, 1):
+            results_text += f"\nשאילתה {i}:\n{qr.query}\n\n"
+            if qr.error:
+                results_text += f"שגיאה: {qr.error}\n\n"
+            else:
+                # Format result as table
+                if len(qr.result) == 0:
+                    results_text += "תוצאה: אין תוצאות\n\n"
+                else:
+                    results_text += f"תוצאה ({len(qr.result)} שורות):\n"
+                    results_text += qr.result.to_string(index=False)
+                    results_text += "\n\n"
+        
+        prompt = f"""אתה אנליסט עסקי בכיר במשרד הפנים, מומחה בייעול תהליכים דיגיטליים ושיפור חוויות המשתמשים.
+
+המשתמש שאל שאלה על משובי משתמשים על שירותים דיגיטליים.
+
+שאלת המשתמש: {query}
+
+כדי לענות על השאלה, בוצעו השאילתות הבאות והתקב��ו התוצאות הבאות:
+
+{results_text}
+
+המשימה שלך: כתוב תשובה מסכמת, ברורה ובשפה חופשית שמבוססת על התוצאות.
+
+דרישות:
+1. תשובה מפורטת ומקיפה (5-7 פסקאות, 400-600 מילים)
+2. תשובה ברורה ומסודרת - לא גיבוב של מילים
+3. כלול מספרים מדויקים מהתוצאות
+4. הסבר את המשמעות העסקית של הממצאים
+5. כלול המלצות מעשיות לשיפור
+6. כתוב בעברית מקצועית וקולחת
+7. תן תשובה שמראה הבנה עמוקה של הנתונים
+
+מבנה התשובה:
+1. פתיחה - סיכום מנהלים קצר (2-3 משפטים)
+2. ניתוח מפורט של הממצאים (3-4 פסקאות)
+3. תובנות עסקיות והמלצות (2-3 פסקאות)
+4. סיכום (1-2 משפטים)
+
+אם יש שגיאות בשאילתות, ציין זאת בתשובה."""
+
+        # 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.8,
+                    "top_p": 0.95,
+                    "top_k": 40,
+                    "max_output_tokens": 4000,
+                }
+                response = model.generate_content(prompt, generation_config=generation_config)
+                text = getattr(response, "text", None)
+                if text and text.strip():
+                    return text.strip()
+            except Exception as e:
+                print(f"Gemini error in synthesis: {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": prompt}],
+                    temperature=0.8,
+                    max_tokens=3000,
+                )
+                text = response.choices[0].message.content
+                if text:
+                    return text.strip()
+            except Exception as e:
+                print(f"OpenAI error in synthesis: {e}", flush=True)
+        
+        # Fallback: return basic summary
+        return f"בוצעו {len(sql_queries)} שאילתות. {len([r for r in query_results if not r.error])} הצליחו."
+    
+    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).
+        """
+        visualizations = []
+        
+        for i, qr in enumerate(query_results, 1):
+            if qr.error or len(qr.result) == 0:
+                continue
+            
+            # Determine visualization type based on result structure
+            result = qr.result
+            
+            # If result has 2 columns, might be a bar chart
+            if len(result.columns) == 2:
+                col1, col2 = result.columns
+                # If first column is categorical and second is numeric
+                if result[col2].dtype in ['int64', 'float64']:
+                    visualizations.append({
+                        "type": "bar",
+                        "title": f"תוצאה של שאילתה {i}",
+                        "x": col1,
+                        "y": col2,
+                        "data": result.to_dict('records')
+                    })
+            
+            # If result has 1 column with numeric values, might be a distribution
+            elif len(result.columns) == 1:
+                col = result.columns[0]
+                if result[col].dtype in ['int64', 'float64']:
+                    visualizations.append({
+                        "type": "histogram",
+                        "title": f"תוצאה של שאילתה {i}",
+                        "x": col,
+                        "data": result[col].tolist()
+                    })
+        
+        return visualizations if visualizations else None
+

app/static/app.js

@@ -60,7 +60,8 @@ async function sendQuery() {
     return;
   }
   
-  const body = { query: q, top_k: 100 }; // Use 100 records for comprehensive RAG-based analysis
+  // Check which approach to use
+  const approach = document.querySelector('input[name="approach"]:checked')?.value || 'sql';
   
   // Show loading state
   const sendBtn = document.getElementById('send');
@@ -69,7 +70,12 @@ async function sendQuery() {
   sendBtn.textContent = '⏳ שולח...';
   
   try {
-    const r = await fetch('/query', {
+    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 };
+    
+    const r = await fetch(endpoint, {
       method: 'POST', 
       headers: {'Content-Type':'application/json'}, 
       body: JSON.stringify(body)
@@ -93,16 +99,29 @@ async function sendQuery() {
       summaryDiv.innerHTML = '<span style="color: #d32f2f;">לא התקבלה תשובה מהשרת</span>';
     }
     
-    // Show sources if checkbox is checked
+    // Show sources/query results if checkbox is checked
     const showSources = document.getElementById('show-sources')?.checked;
     const sourcesDiv = document.getElementById('resp-sources');
-    if (showSources && j.results && j.results.length > 0) {
-      sourcesDiv.style.display = 'block';
-      sourcesDiv.innerHTML = formatSources(j.results);
+    
+    if (showSources) {
+      if (approach === 'sql' && 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';
+      }
     } else {
       if (sourcesDiv) sourcesDiv.style.display = 'none';
     }
     
+    // Show visualizations if SQL approach and visualizations available
+    if (approach === 'sql' && j.visualizations && j.visualizations.length > 0) {
+      showVisualizations(j.visualizations);
+    }
+    
     // Refresh history
     await refreshHistory();
     
@@ -121,6 +140,93 @@ async function sendQuery() {
   }
 }
 
+function formatSQLResults(data) {
+  let html = '<div style="margin-top: 20px;"><h4 style="color: #1976d2; margin-bottom: 12px;">שאילתות SQL שבוצעו:</h4>';
+  
+  if (data.sql_queries && data.sql_queries.length > 0) {
+    html += '<div style="margin-bottom: 20px;">';
+    data.sql_queries.forEach((query, idx) => {
+      html += `<div style="background: #f5f5f5; padding: 12px; border-radius: 8px; margin-bottom: 12px; font-family: monospace; font-size: 13px; direction: ltr; text-align: left;">`;
+      html += `<strong>שאילתה ${idx + 1}:</strong><br>${escapeHtml(query)}</div>`;
+    });
+    html += '</div>';
+  }
+  
+  if (data.query_results && data.query_results.length > 0) {
+    html += '<h4 style="color: #1976d2; margin-bottom: 12px;">תוצאות:</h4>';
+    data.query_results.forEach((qr, idx) => {
+      html += `<div style="margin-bottom: 20px; padding: 16px; background: #f8f9fa; border-radius: 8px;">`;
+      html += `<strong>תוצאה ${idx + 1}:</strong> `;
+      if (qr.error) {
+        html += `<span style="color: #d32f2f;">שגיאה: ${escapeHtml(qr.error)}</span>`;
+      } else {
+        html += `<span style="color: #4caf50;">${qr.row_count} שורות</span>`;
+        if (qr.result && qr.result.length > 0) {
+          html += '<table style="width: 100%; margin-top: 12px; border-collapse: collapse;">';
+          // Header
+          html += '<thead><tr style="background: #e3f2fd;">';
+          Object.keys(qr.result[0]).forEach(col => {
+            html += `<th style="padding: 8px; text-align: right; border: 1px solid #ddd;">${escapeHtml(col)}</th>`;
+          });
+          html += '</tr></thead><tbody>';
+          // Rows (limit to 10 for display)
+          qr.result.slice(0, 10).forEach(row => {
+            html += '<tr>';
+            Object.values(row).forEach(val => {
+              html += `<td style="padding: 8px; border: 1px solid #ddd;">${escapeHtml(String(val))}</td>`;
+            });
+            html += '</tr>';
+          });
+          html += '</tbody></table>';
+          if (qr.result.length > 10) {
+            html += `<div style="margin-top: 8px; color: #666; font-size: 14px;">...ועוד ${qr.result.length - 10} שורות</div>`;
+          }
+        }
+      }
+      html += '</div>';
+    });
+  }
+  
+  html += '</div>';
+  return html;
+}
+
+function showVisualizations(visualizations) {
+  // Create or get visualizations container
+  let vizContainer = document.getElementById('resp-visualizations');
+  if (!vizContainer) {
+    vizContainer = document.createElement('div');
+    vizContainer.id = 'resp-visualizations';
+    vizContainer.style.marginTop = '20px';
+    document.getElementById('last-response').appendChild(vizContainer);
+  }
+  
+  vizContainer.style.display = 'block';
+  vizContainer.innerHTML = '<h4 style="color: #1976d2; margin-bottom: 12px;">📊 גרפיקות:</h4>';
+  
+  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.innerHTML = `<h5 style="margin-top: 0; color: #1976d2;">${viz.title}</h5>`;
+    vizDiv.innerHTML += `<div id="viz-${idx}" style="height: 300px;"></div>`;
+    
+    vizContainer.appendChild(vizDiv);
+    
+    // Use Chart.js or similar for visualization
+    // For now, just show a placeholder
+    document.getElementById(`viz-${idx}`).innerHTML = `
+      <div style="text-align: center; padding: 40px; color: #666;">
+        📊 גרפיקה מסוג ${viz.type}<br>
+        <small>תמיכה בגרפיקות תתווסף בקרוב</small>
+      </div>
+    `;
+  });
+}
+
 function formatResponse(text) {
   // Format markdown-like text (bold, lists, etc.)
   let formatted = escapeHtml(text);

app/static/index.html

@@ -203,6 +203,13 @@
         <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>