update

.query_history.json

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

.uvicorn.log

@@ -0,0 +1,88 @@
+INFO:     Started server process [70640]
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.
+INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
+
+
+huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...
+To disable this warning, you can either:
+	- Avoid using `tokenizers` before the fork if possible
+	- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)
+INFO:     127.0.0.1:55678 - "POST /query HTTP/1.1" 200 OK
+
+
+INFO:     127.0.0.1:55706 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55717 - "GET / HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55717 - "GET /static/app.js HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55717 - "POST /health HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55717 - "GET /history HTTP/1.1" 200 OK
+
+INFO:     127.0.0.1:55717 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55717 - "GET /history HTTP/1.1" 200 OK
+
+INFO:     127.0.0.1:55726 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET / HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET /static/app.js HTTP/1.1" 304 Not Modified
+INFO:     127.0.0.1:55737 - "POST /health HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET / HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "POST /health HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET /history HTTP/1.1" 200 OK
+
+INFO:     127.0.0.1:55737 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET / HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "POST /health HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "POST /history/clear HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "POST /history/clear HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "POST /history/clear HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "POST /history/clear HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55737 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55752 - "GET /apple-touch-icon-precomposed.png HTTP/1.1" 404 Not Found
+INFO:     127.0.0.1:55753 - "GET /apple-touch-icon.png HTTP/1.1" 404 Not Found
+INFO:     127.0.0.1:55754 - "GET /favicon.ico HTTP/1.1" 404 Not Found
+INFO:     127.0.0.1:55795 - "GET / HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55795 - "GET /static/app.js HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55795 - "POST /health HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55795 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55795 - "GET /favicon.ico HTTP/1.1" 404 Not Found
+
+INFO:     127.0.0.1:55795 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55795 - "GET /history HTTP/1.1" 200 OK
+
+INFO:     127.0.0.1:55821 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55821 - "GET /history HTTP/1.1" 200 OK
+
+INFO:     127.0.0.1:55824 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55824 - "GET /history HTTP/1.1" 200 OK
+
+INFO:     127.0.0.1:55824 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55824 - "GET /history HTTP/1.1" 200 OK
+
+INFO:     127.0.0.1:55824 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55824 - "GET /history HTTP/1.1" 200 OK
+
+INFO:     127.0.0.1:55839 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55839 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55846 - "POST /history/clear HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55846 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55846 - "POST /history/clear HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55846 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55846 - "POST /history/clear HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55846 - "GET /history HTTP/1.1" 200 OK
+
+
+
+INFO:     127.0.0.1:55846 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55846 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55850 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55850 - "GET /history HTTP/1.1" 200 OK
+
+INFO:     127.0.0.1:55849 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55849 - "GET /history HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55850 - "POST /query HTTP/1.1" 200 OK
+INFO:     127.0.0.1:55850 - "GET /history HTTP/1.1" 200 OK

PROJECT_COMPLETE.md

@@ -30,6 +30,7 @@ Build a **Feedback Analysis RAG Agent** that:
 - [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)

app/api.py

@@ -4,9 +4,12 @@ from typing import List, Optional, Dict, Any
 
 import numpy as np
 import pandas as pd
-from fastapi import FastAPI, Query
-from fastapi.responses import ORJSONResponse
-from pydantic import BaseModel
+from fastapi import FastAPI, Query, Request
+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
@@ -21,16 +24,36 @@ app = FastAPI(title="Feedback Analysis RAG Agent", version="1.0.0", default_resp
 svc = RAGService()
 embedder = svc.embedder
 
+# Simple in-memory history persisted best-effort to `.query_history.json`
+history_file = Path(".query_history.json")
+history = []
+if history_file.exists():
+    try:
+        with history_file.open("r", encoding="utf-8") as f:
+            history = json.load(f)
+    except Exception:
+        history = []
+
+
+def save_history() -> None:
+    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
+        pass
+
 
 class QueryRequest(BaseModel):
-    query: str
-    top_k: int = 5
+    query: str = Field(..., example="תסווג את התלונות 5 סוגים")
+    top_k: int = Field(5, example=5)
 
 
 class QueryResponse(BaseModel):
     query: str
     summary: Optional[str]
-    results: List[Dict[str, Any]]
+    # `results` (example records) removed deliberately: API returns only
+    # an analyst-style `summary` to clients.
 
 
 @app.post("/health")
@@ -55,40 +78,54 @@ def ingest() -> Dict[str, Any]:
 
 
 @app.post("/query", response_model=QueryResponse)
-def query(req: QueryRequest) -> QueryResponse:
-    """Free-form question answering over feedback data."""
+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 QueryResponse(
-            query=out.query,
-            summary=out.summary,
-            results=[
-                {
-                    "score": float(r.score),  # Convert numpy float to Python float
-                    "service": str(r.row.get(settings.service_column, "")),
-                    "level": str(r.row.get(settings.level_column, "")),
-                    "text": str(r.row.get(settings.text_column, "")),
-                }
-                for r in out.results
-            ],
-        )
+
+        # Only return the analyst-style summary to the client. Do not include
+        # example records or raw contexts in the API response.
+        resp_dict = {"query": out.query, "summary": out.summary}
+
+        # append to history (store only the summary)
+        try:
+            history.append({"query": out.query, "response": {"summary": out.summary}})
+            save_history()
+        except Exception:
+            pass
+
+        return QueryResponse(**resp_dict)
     except FileNotFoundError:
-        return QueryResponse(
+        resp = QueryResponse(
             query=req.query,
             summary="Error: Vector index not found. Please run /ingest first.",
-            results=[]
         )
+        try:
+            history.append({"query": resp.query, "response": {"summary": resp.summary}})
+            save_history()
+        except Exception:
+            pass
+        return resp
     except Exception as e:
-        return QueryResponse(
+        resp = QueryResponse(
             query=req.query,
             summary=f"Error: {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 = 5
+    num_topics: int = Field(5, example=5)
 
 
 @app.post("/topics")
@@ -183,7 +220,7 @@ def topics(req: TopicsRequest) -> Dict[str, Any]:
 
 
 class SentimentRequest(BaseModel):
-    limit: int = 100
+    limit: int = Field(100, example=50)
 
 
 @app.post("/sentiment")
@@ -198,3 +235,33 @@ def sentiment(req: SentimentRequest) -> Dict[str, Any]:
     out = analyze_sentiments(texts)
     return {"count": len(out), "results": out}
 
+
+# Mount static files for a simple frontend if present
+static_dir = Path(__file__).parent / "static"
+if static_dir.exists():
+    # Serve static assets under /static/* (so index.html can reference /static/app.js)
+    app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+
+
+@app.get("/")
+def root() -> HTMLResponse:
+    """Serve the main index.html for the frontend."""
+    try:
+        html = (static_dir / "index.html").read_text(encoding="utf-8")
+        return HTMLResponse(html)
+    except Exception:
+        return HTMLResponse("<html><body><h1>Frontend not available</h1></body></html>", status_code=404)
+
+
+@app.get("/history")
+def get_history() -> Dict[str, Any]:
+    return {"history": history}
+
+
+@app.post("/history/clear")
+def clear_history() -> Dict[str, Any]:
+    global history
+    history = []
+    save_history()
+    return {"status": "cleared"}
+

app/rag_service.py

@@ -106,10 +106,175 @@ class RAGService:
         # Fallback: simple extractive "summary"
         return " ".join(contexts[:3])
 
+    def synthesize(self, query: str, results: List[SearchResult], contexts: List[str], max_contexts: int = 40) -> 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
+
+        # Limit number of contexts and truncate each to keep prompt size reasonable
+        safe_ctxs = []
+        for c in contexts[:max_contexts]:
+            # truncate to ~800 chars to avoid extremely long prompts
+            safe_ctxs.append((c[:800] + "...") if len(c) > 800 else c)
+
+        joined = "\n\n".join(f"- {c}" for c in 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 = (
+            "You are an experienced information-systems analyst and senior data analyst working for a government ministry.\n"
+            "You have access to the full feedback dataset and metadata (service name, level).\n"
+            "Your task: produce a clear, structured, analyst-style answer to the user's question.\n"
+            "Requirements:\n"
+            "- Always synthesize across the provided examples and aggregate data; do NOT return raw snippets or 'most relevant' lists.\n"
+            "- Where applicable, compute simple aggregates over the dataset (counts, averages by service or by level).\n"
+            "- Provide: 1) Executive summary (2-4 sentences), 2) Key themes with short examples, 3) Likely root causes, 4) Business impact and priority, 5) Recommended next steps, 6) Suggested KPIs.\n"
+            "- If the user asks to split feedback into N topics, provide the N topics and a brief description and count for each.\n"
+            "- If the user asks about items with level < 3, filter by 'level' field accordingly and summarize services with low levels.\n"
+            "- Be explicit about uncertainty and flag where more data is needed.\n"
+        )
+
+        # Compute simple aggregates locally to include in the prompt: counts by service and average level
+        try:
+            df = load_feedback()
+            # basic aggregates
+            total = len(df)
+            counts_by_service = df.groupby(settings.service_column).size().sort_values(ascending=False).head(10).to_dict()
+            avg_level_by_service = df.groupby(settings.service_column)[settings.level_column].mean().sort_values(ascending=False).head(10).to_dict()
+            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()
+        except Exception:
+            total = None
+            counts_by_service = {}
+            avg_level_by_service = {}
+            low_level_counts = {}
+
+        aggregates_str = f"Total feedback: {total}\nTop services by count: {counts_by_service}\nTop services by avg level: {avg_level_by_service}\nLow-level counts (level<3): {low_level_counts}\n"
+
+        # Special-case: the user asked to split into N topics (e.g., "חלק את המשובים ל5 נושאים")
+        import re
+        m = re.search(r"(\d+)\s*נוש", query)
+        if ("חלק" in query and "נוש" in query) or m:
+            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 compact summary of clusters with sample examples
+                clusters: Dict[int, list] = {}
+                for label, text in zip(res.labels, texts):
+                    clusters.setdefault(int(label), []).append(text)
+
+                cluster_summaries = []
+                for tid, items in clusters.items():
+                    sample = items[:3]
+                    cluster_summaries.append(f"Cluster {tid}: count={len(items)}, examples: {sample}")
+
+                clusters_str = "\n".join(cluster_summaries[:n_topics])
+
+                prompt = (
+                    f"{instruction}\n\n{lang_instruction}.\n\nUser query:\n{query}\n\nDataset aggregates:\n{aggregates_str}\n\nCluster summaries (samples):\n{clusters_str}\n\n"
+                    "Using the cluster summaries above, provide for each cluster: 1) a concise topic name (2-4 words), 2) 1-2 sentence description of the theme, and 3) recommended next steps/prioritization. Present as a numbered list."
+                )
+            except Exception:
+                # 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)):
+            # User asks about items with level < 3
+            try:
+                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
+                    res = kmeans_topics(embeddings, num_topics=3)
+                    clusters: Dict[int, list] = {}
+                    for label, text in zip(res.labels, low_texts):
+                        clusters.setdefault(int(label), []).append(text)
+                    clusters_str = "\n".join([f"Cluster {tid}: count={len(items)}, examples: {items[:3]}" for tid, items in clusters.items()])
+                else:
+                    clusters_str = "(no low-level feedback found)"
+
+                prompt = (
+                    f"{instruction}\n\n{lang_instruction}.\n\nUser query:\n{query}\n\nDataset aggregates (low-level):\n{aggregates_str}\n\nLow-level cluster samples:\n{clusters_str}\n\n"
+                    "Summarize the dominant topic(s) among low-rated feedback and identify which services are most affected. Provide recommended remediation steps and priority." 
+                )
+            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."
+                )
+        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\nUser query:\n{query}\n\nDataset aggregates:\n{aggregates_str}\n\nService-level stats:\n{svc_str}\n\n"
+                    "Using the service-level statistics and sampled feedback, describe which services have serious issues, which are working well overall, and provide prioritized recommendations for remediation and monitoring."
+                )
+            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\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."
+            )
+
+        # 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")
+                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.3,
+                    max_tokens=700,
+                )
+                return resp.choices[0].message.content
+            except Exception:
+                pass
+
+        # Fallback: short extractive-ish synthesis
+        # Compose a short paragraph from top contexts
+        extract = " ".join(contexts[:5])
+        return extract
+
     def query(self, query: str, top_k: int = 5) -> RetrievalOutput:
-        results = self.retrieve(query, top_k=top_k)
+        # Increase retrieval breadth by default so the LLM can synthesize across
+        # a broader set of feedback items (not only the top 5). This helps produce
+        # free-form analyst-style answers that consider more of the encoded data.
+        adjusted_k = max(top_k, 40)
+        results = self.retrieve(query, top_k=adjusted_k)
         contexts = [r.row[settings.text_column] for r in results]
-        summary = self.summarize(query, contexts)
+        # Use the new synthesizing free-form answer by default so responses are
+        # written as an experienced data analyst and synthesize across retrieved data.
+        summary = self.synthesize(query, results, contexts, max_contexts=adjusted_k)
         return RetrievalOutput(query=query, results=results, summary=summary)
 
     def answer(self, query: str, top_k: int = 5) -> RetrievalOutput:

app/static/app.js

@@ -0,0 +1,83 @@
+async function checkServer() {
+  try {
+    const r = await fetch('/health', {method: 'POST', headers: {'Content-Type':'application/json'}, body: JSON.stringify({})});
+    if (!r.ok) throw new Error('no');
+    const j = await r.json();
+    document.getElementById('server-status').textContent = j.status || 'ok';
+  } catch (e) {
+    document.getElementById('server-status').textContent = 'לא זמין';
+  }
+}
+
+async function refreshHistory() {
+  try {
+    const r = await fetch('/history');
+    const j = await r.json();
+    const h = j.history || [];
+    const container = document.getElementById('history');
+    container.innerHTML = '';
+    if (h.length === 0) {
+      container.textContent = 'לא נמצאו שאילתות קודמות.';
+      return;
+    }
+    // Respect the UI toggle: only include example snippets in history when
+    // the user opts to show sources. History entries are simple objects: {query, response: {summary}}
+    const showSources = document.getElementById('show-sources') && document.getElementById('show-sources').checked;
+    h.slice().reverse().forEach(entry => {
+      const el = document.createElement('div');
+      el.className = 'card';
+      const q = document.createElement('div'); q.innerHTML = '<strong>שאלה:</strong> ' + escapeHtml(entry.query);
+      const s = document.createElement('div'); s.innerHTML = '<strong>סיכום:</strong> ' + (entry.response && entry.response.summary ? escapeHtml(entry.response.summary) : '');
+      const res = document.createElement('div');
+      // We intentionally do not render example records unless the server
+      // and client explicitly provide them. By default this is hidden.
+      el.appendChild(q); el.appendChild(s); el.appendChild(res);
+      container.appendChild(el);
+    });
+  } catch (e) {
+    console.error('history fetch failed', e);
+  }
+}
+
+function escapeHtml(unsafe) {
+  return unsafe
+       .replace(/&/g, "&amp;")
+       .replace(/</g, "&lt;")
+       .replace(/>/g, "&gt;")
+       .replace(/\"/g, "&quot;")
+       .replace(/'/g, "&#039;");
+}
+
+async function sendQuery() {
+  const q = document.getElementById('query').value;
+  const top_k = parseInt(document.getElementById('top_k').value || '5', 10);
+  const body = { query: q, top_k };
+  try {
+    const r = await fetch('/query', {method: 'POST', headers: {'Content-Type':'application/json'}, body: JSON.stringify(body)});
+    const j = await r.json();
+    // show last response (summary is primary)
+    document.getElementById('last-response').style.display = 'block';
+    document.getElementById('resp-summary').textContent = j.summary || '';
+    // we no longer show raw JSON or example records by default
+    await refreshHistory();
+  } catch (e) {
+    alert('שגיאה בשליחת השאלה — בדוק את הקונסול');
+    console.error(e);
+  }
+}
+
+async function clearHistory() {
+  try {
+    await fetch('/history/clear', {method: 'POST'});
+    await refreshHistory();
+  } catch (e) {
+    console.error('clear failed', e);
+  }
+}
+
+window.addEventListener('load', async () => {
+  document.getElementById('send').addEventListener('click', sendQuery);
+  document.getElementById('clear-history').addEventListener('click', clearHistory);
+  await checkServer();
+  await refreshHistory();
+});

app/static/index.html

@@ -0,0 +1,67 @@
+<!doctype html>
+<html lang="he">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Feedback RAG — Frontend</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Noto Sans', sans-serif; margin: 0; direction: rtl; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; color: #0b2545; }
+    .container { max-width: 1000px; margin: 24px auto; padding: 24px; }
+    h1 { color: white; text-shadow: 0 2px 4px rgba(0,0,0,0.2); margin: 0 0 24px 0; }
+    header { display:flex; align-items:center; justify-content:space-between; gap:12px; margin-bottom: 0; }
+    textarea { width: 100%; height: 120px; font-size: 16px; padding:12px; border-radius:8px; border:2px solid #d0d7e6; font-family: inherit; }
+    textarea:focus { outline: none; border-color: #667eea; box-shadow: 0 0 0 3px rgba(102,126,234,0.1); }
+    input[type="number"] { padding: 8px; border-radius:6px; border:1px solid #d0d7e6; font-size:14px; }
+    button { padding: 10px 14px; margin-top: 8px; border-radius:6px; border: none; cursor: pointer; font-size:14px; font-weight:600; transition: all 0.2s; }
+    .primary { background: #0b63ff; color: white; }
+    .primary:hover { background: #0050cc; transform: translateY(-2px); box-shadow: 0 4px 12px rgba(11,99,255,0.3); }
+    .muted { background: #eef3ff; color: #0b2545; }
+    .muted:hover { background: #dde6ff; }
+    .card { border-radius: 12px; padding: 20px; margin-top: 16px; background: white; box-shadow: 0 10px 30px rgba(0,0,0,0.15); }
+    .summary { font-size: 16px; line-height: 1.7; color: #073763; white-space: pre-wrap; word-wrap: break-word; }
+    .result { white-space: pre-wrap; }
+    header .title { font-size: 20px; margin:0 }
+    .history-list { margin-top: 20px; }
+    .small { color: #666; font-size: 12px; }
+    .controls { display:flex; gap:12px; align-items:center; margin-top:12px; flex-wrap: wrap; }
+    label { display:block; margin-bottom:6px; color: #0b2545; font-weight:500; }
+    .response-badge { display: inline-block; background: #e8f5e9; color: #2e7d32; padding: 4px 8px; border-radius: 4px; font-size: 12px; margin-bottom: 12px; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>Feedback RAG — ממשק</h1>
+      <div class="small">שרת: <span id="server-status">...בדיקה</span></div>
+    </header>
+
+    <section class="card">
+      <label for="query">שאלה</label>
+      <textarea id="query">תסווג את התלונות 5 סוגים</textarea>
+      <div>
+        <label for="top_k">מספר תוצאות (top_k)</label>
+        <input id="top_k" type="number" value="5" min="1" max="50" style="width:80px;" />
+      </div>
+      <div style="margin-top:8px;">
+        <label><input type="checkbox" id="show-sources" /> הצג דוגמאות (Sources)</label>
+        <span class="small" style="margin-left:12px;">ברירת מחדל: מוסתר — יוצג רק הסיכום האנליטי</span>
+      </div>
+      <div style="display:flex;gap:8px;margin-top:12px;">
+        <button id="send" class="primary">🔍 שאל</button>
+        <button id="clear-history" class="muted">🗑️ נקה היסטוריה</button>
+      </div>
+    </section>
+
+    <section id="last-response" class="card" style="display:none;">
+      <h3>✓ תגובה אנליטית</h3>
+      <div id="resp-summary" class="summary"></div>
+    </section>
+
+    <section class="card history-list">
+      <h3>היסטוריית שאלות</h3>
+      <div id="history"></div>
+    </section>
+  </div>
+  <script src="/static/app.js"></script>
+</body>
+</html>

scripts/smoke_check.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""Simple smoke check that hits the running FastAPI server root and /query.
+
+This uses only the standard library so it should work in the project's venv.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+
+
+def get_root() -> str:
+    with urllib.request.urlopen("http://127.0.0.1:8000/") as resp:
+        return resp.read().decode("utf-8")
+
+
+def post_query(q: str):
+    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"})
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        return json.load(resp)
+
+
+def main() -> None:
+    print("Checking http://127.0.0.1:8000/ ...")
+    try:
+        root = get_root()
+        print("Root response length:", len(root))
+    except Exception as e:
+        print("Failed to GET root:", e)
+        return
+
+    sample_q = "מה הבעיות העיקריות שמשתמשים מציינים?"
+    print("Posting sample query to /query ...")
+    try:
+        resp = post_query(sample_q)
+        print("Query response keys:", list(resp.keys()))
+        print("Summary (truncated):\n", (resp.get("summary") or "(no summary)")[:800])
+    except Exception as e:
+        print("Failed to POST /query:", e)
+
+
+if __name__ == "__main__":
+    main()