Update app.py

app.py

@@ -1,180 +1,580 @@
-import gradio as gr
-import pandas as pd
+# -*- coding: utf-8 -*-
+"""
+Text2Receipt — Hugging Face Gradio Space
+=========================================
+Pipeline:
+  raw Hebrew note
+    → fine-tuned parser (gemma-2-2b-it + LoRA)
+    → agentic clarifier  (+5% bonus — detects legally-ambiguous fields)
+    → deterministic complete()  (VAT · serial · allocation number)
+    → fiscal document display
+    → FAISS recommender  (3 similar past receipts)
+
+Repos used:
+  Dataset : yonilev/Text2Receipt
+  Model   : yonilev/Text2Receipt-parser  (LoRA adapter + embeddings)
+  Space   : yonilev/Text2Receipt
+"""
+import os, json, re, random
 import numpy as np
-import torch
-from datasets import load_dataset
-from sentence_transformers import SentenceTransformer
-from sklearn.metrics.pairwise import cosine_similarity
-
-# ── Startup: load everything once ────────────────────────────────────────────
-print("Loading CLIP model...")
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-model = SentenceTransformer("clip-ViT-B-32", device=DEVICE)
-
-print("Loading embeddings...")
-embed_df = pd.read_parquet("fashion_embeddings.parquet")
-EMBED_MATRIX = np.array(embed_df["embedding"].tolist(), dtype=np.float32)
-
-print("Loading dataset (for images)...")
-dataset = load_dataset("ashraq/fashion-product-images-small", split="train")
-id_to_idx = {int(dataset[i]["id"]): i for i in range(len(dataset))}
-
-CATEGORIES = ["All"] + sorted(embed_df["masterCategory"].unique().tolist())
-GENDERS    = ["All"] + sorted(embed_df["gender"].unique().tolist())
-print(f"Ready — {len(embed_df):,} items indexed on {DEVICE}")
-
-
-# ── Core logic ────────────────────────────────────────────────────────────────
-def _mmr_select(similarities, filtered_sims, n, lam=0.7):
-    selected, candidates = [], np.where(filtered_sims > -1)[0].tolist()
-    while len(selected) < n and candidates:
-        if not selected:
-            best = candidates[int(np.argmax(filtered_sims[candidates]))]
-        else:
-            scores = [
-                lam * similarities[c]
-                - (1 - lam) * cosine_similarity(EMBED_MATRIX[c:c+1], EMBED_MATRIX[selected]).max()
-                for c in candidates
-            ]
-            best = candidates[int(np.argmax(scores))]
-        selected.append(best); candidates.remove(best)
-    return selected
+import gradio as gr
+
+# ── repo constants ────────────────────────────────────────────────────────────
+DATASET_REPO = "yonilev/Text2Receipt"
+MODEL_REPO   = "yonilev/Text2Receipt-parser"
+BASE_MODEL   = os.environ.get("BASE_MODEL", "unsloth/gemma-2-2b-it")
+
+import t2r_core as core
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 1.  Lazy init — load heavy resources once on first request
+# ═════════════════════════════════════════════════════════════════════════════
+_STATE: dict = {"ready": False}
+
+def _lazy_init():
+    if _STATE["ready"]:
+        return
+    import torch
+    from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+    from peft import PeftModel
+    from sentence_transformers import SentenceTransformer
+    import faiss
+    from huggingface_hub import hf_hub_download
+    import pandas as pd
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    _STATE["device"] = device
+    _STATE["rng"]    = random.Random(42)
+
+    # ── parser model ──────────────────────────────────────────────────────────
+    bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
+                             bnb_4bit_compute_dtype=torch.float16,
+                             bnb_4bit_use_double_quant=True)
+    tok = AutoTokenizer.from_pretrained(BASE_MODEL)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    tok.padding_side = "left"
+
+    try:
+        base = AutoModelForCausalLM.from_pretrained(
+            BASE_MODEL, quantization_config=bnb, device_map="auto",
+            torch_dtype=torch.float16, attn_implementation="eager")
+        model = PeftModel.from_pretrained(base, MODEL_REPO)
+        print("✅ loaded fine-tuned adapter from", MODEL_REPO)
+    except Exception as e:
+        print(f"⚠ adapter load failed ({e}); falling back to base model")
+        model = AutoModelForCausalLM.from_pretrained(
+            BASE_MODEL, quantization_config=bnb, device_map="auto",
+            torch_dtype=torch.float16, attn_implementation="eager")
+
+    model.eval()
+    _STATE["tok"]   = tok
+    _STATE["model"] = model
+
+    # ── embeddings + FAISS ────────────────────────────────────────────────────
+    emb_path   = hf_hub_download(MODEL_REPO, "receipts_embeddings.npy", repo_type="model")
+    store_path = hf_hub_download(MODEL_REPO, "receipts_store.parquet",  repo_type="model")
+    manifest_path = hf_hub_download(MODEL_REPO, "embeddings_manifest.json", repo_type="model")
+
+    emb   = np.load(emb_path).astype("float32")
+    store = pd.read_parquet(store_path)
+    with open(manifest_path) as f:
+        manifest = json.load(f)
+
+    faiss.normalize_L2(emb)
+    index = faiss.IndexFlatIP(emb.shape[1])
+    index.add(emb)
+
+    enc = SentenceTransformer(manifest["embed_model"],
+                              device=device)
+    _STATE["enc"]       = enc
+    _STATE["index"]     = index
+    _STATE["store"]     = store
+    _STATE["e5_family"] = manifest.get("e5_family", False)
+    _STATE["ready"]     = True
+    print("✅ FAISS index ready —", emb.shape[0], "vectors")
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 2.  Parser helpers
+# ═════════════════════════════════════════════════════════════════════════════
+INSTRUCTION = (
+    "אתה ממיר הערת הכנסה חופשית בעברית למבנה JSON. "
+    "חלץ אך ורק את מה שכתוב בהערה: שם הלקוח (client_name), "
+    "האם הלקוח עסק (client_is_business), ורשימת פריטים (items) "
+    "כאשר לכל פריט תיאור (description), מחיר ליחידה (unit_price) וכמות (quantity). "
+    "החזר JSON תקין בלבד, ללא טקסט נוסף."
+)
+
+def _build_prompt(raw_text: str) -> str:
+    return f"{INSTRUCTION}\n\nהערה: {raw_text}\n\nJSON:"
+
+def _extract_json(text: str) -> dict | None:
+    s = text.find("{")
+    if s < 0:
+        return None
+    depth = 0
+    for i in range(s, len(text)):
+        if text[i] == "{":  depth += 1
+        elif text[i] == "}":
+            depth -= 1
+            if depth == 0:
+                try:    return json.loads(text[s:i+1])
+                except: return None
+    return None
+
+def model_parse(raw_text: str) -> dict | None:
+    """Run fine-tuned model; return parse dict or None on failure."""
+    tok, model = _STATE["tok"], _STATE["model"]
+    msgs   = [{"role": "user", "content": _build_prompt(raw_text)}]
+    prompt = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
+    enc    = tok(prompt, return_tensors="pt",
+                 add_special_tokens=False).to(model.device)
+    import torch
+    with torch.no_grad():
+        out = model.generate(**enc, max_new_tokens=200,
+                             do_sample=False,
+                             pad_token_id=tok.pad_token_id)
+    decoded = tok.decode(out[0, enc["input_ids"].shape[1]:],
+                         skip_special_tokens=True)
+    return _extract_json(decoded)
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 3.  Agentic clarification logic  (+5% bonus)
+# ═════════════════════════════════════════════════════════════════════════════
+import datetime as _dt
+
+def _today() -> _dt.date:
+    return _dt.date.today()
+
+def _missing_fields(parse: dict | None) -> list[str]:
+    """Return list of missing mandatory fields that affect the document legally."""
+    missing = []
+    if parse is None:
+        return ["parse_failed"]
+    if not parse.get("client_name", "").strip():
+        missing.append("client_name")
+    if not parse.get("items"):
+        missing.append("items")
+    # doc_type not extractable from notes — always needs clarification for allocation
+    return missing
+
+def _needs_allocation_clarification(parse: dict) -> bool:
+    """Return True when the doc_type choice changes whether allocation is required."""
+    if parse is None:
+        return False
+    subtotal = sum(
+        it.get("unit_price", 0) * it.get("quantity", 1)
+        for it in parse.get("items", [])
+    )
+    threshold = core.allocation_threshold_for_date(_today())
+    is_biz    = parse.get("client_is_business", False)
+    # allocation only matters for authorized dealer + biz client + subtotal ≥ threshold
+    # but we don't know issuer status here; ask when subtotal is near or above threshold
+    return bool(is_biz) and subtotal >= threshold * 0.8  # 80% buffer
+
+def clarification_questions(parse: dict | None, answers: dict) -> list[str]:
+    """
+    Agentic loop: generate next question(s) given current parse + prior answers.
+    Returns [] when all necessary info is available.
+    """
+    questions = []
+    missing = _missing_fields(parse)
+
+    if "parse_failed" in missing:
+        questions.append("לא הצלחתי לחלץ פרטים. האם תוכל לנסח מחדש? לדוגמה: 'קיבלתי 500₪ מ[שם] על [שירות]'")
+        return questions
+
+    if "client_name" in missing and "client_name" not in answers:
+        questions.append("מה שם הלקוח?")
+    if "items" in missing and "items" not in answers:
+        questions.append("מה השירות/המוצר שסופק ובאיזה מחיר?")
+
+    # ask doc_type only if not already answered and allocation is relevant
+    if "doc_type" not in answers:
+        if parse and _needs_allocation_clarification(parse):
+            questions.append(
+                "האם להנפיק חשבונית מס/קבלה (לעסק עם מע\"מ) או קבלה פשוטה?"
+            )
+        elif parse and not parse.get("doc_type"):
+            questions.append(
+                "איזה מסמך לייצר? קבלה / חשבונית מס / חשבונית מס וקבלה?"
+            )
 
+    return questions[:3]  # max 3 questions per round
 
-def get_recommendations(query, category="All", gender="All", diversity=False, n=3):
-    emb  = model.encode(query, convert_to_numpy=True).reshape(1, -1)
-    sims = cosine_similarity(emb, EMBED_MATRIX)[0]
 
-    fsims = sims.copy()
-    if category != "All":
-        fsims[(embed_df["masterCategory"] != category).values] = -1
-    if gender != "All":
-        fsims[(embed_df["gender"] != gender).values] = -1
+def apply_answers(parse: dict | None, answers: dict) -> dict:
+    """Merge user answers into parse dict."""
+    if parse is None:
+        parse = {}
+    p = dict(parse)
+    if "client_name" in answers:
+        p["client_name"] = answers["client_name"]
+    if "doc_type" in answers:
+        raw = answers["doc_type"].strip()
+        if "מס/קבלה" in raw or "מס וקבלה" in raw:
+            p["doc_type"] = "tax_invoice_receipt"
+        elif "מס" in raw:
+            p["doc_type"] = "tax_invoice"
+        else:
+            p["doc_type"] = "receipt"
+    # set safe defaults for missing required fields
+    p.setdefault("doc_type",        "receipt")
+    p.setdefault("date",            _today().isoformat())
+    p.setdefault("payment_method",  "bank_transfer")
+    p.setdefault("amount_basis",    "net")
+    p.setdefault("currency",        "ILS")
+    p.setdefault("client_tax_id",   None)
+    p.setdefault("client_is_business", False)
+    p.setdefault("items",           [])
+    return p
 
-    indices = _mmr_select(sims, fsims, n) if diversity \
-              else np.argsort(fsims)[::-1][:n].tolist()
 
+# ═════════════════════════════════════════════════════════════════════════════
+# 4.  FAISS recommender
+# ═════════════════════════════════════════════════════════════════════════════
+def recommend(query_text: str, k: int = 3) -> list[dict]:
+    """Return k most similar receipts from the full corpus store."""
+    enc   = _STATE["enc"]
+    index = _STATE["index"]
+    store = _STATE["store"]
+    pref  = "query: " if _STATE["e5_family"] else ""
+    q_emb = enc.encode([pref + query_text],
+                       normalize_embeddings=True).astype("float32")
+    _, I = index.search(q_emb, k + 1)  # +1 in case query is in corpus
     results = []
-    for idx in indices:
-        row    = embed_df.iloc[idx]
-        ds_idx = id_to_idx.get(int(row["id"]), -1)
+    for idx in I[0][:k]:
+        row = store.iloc[int(idx)]
         results.append({
-            "image":      dataset[ds_idx]["image"] if ds_idx >= 0 else None,
-            "name":       row["productDisplayName"],
-            "article":    row["articleType"],
-            "color":      row["baseColour"],
-            "gender":     row["gender"],
-            "similarity": float(sims[idx]),
+            "raw_text":    row["raw_text"],
+            "category":    row["category"],
+            "doc_type_he": row["doc_type_he"],
+            "total":       float(row["total"]),
+            "client_name": row["client_name"],
         })
     return results
 
 
-def build_info_html(results):
-    html = '<div style="display:flex;gap:8px;margin-top:8px;">'
-    for i, r in enumerate(results, 1):
-        name = r["name"][:40] + "…" if len(r["name"]) > 40 else r["name"]
-        html += f"""
-        <div style="flex:1;padding:10px;border:1px solid #e0e0e0;border-radius:10px;text-align:center;background:#fafafa;">
-            <b style="font-size:15px;">#{i}</b>
-            <span style="color:#f59e0b;font-size:15px;"> ⭐ {r['similarity']:.3f}</span><br>
-            <span style="font-size:12px;">{name}</span><br>
-            <span style="color:#666;font-size:11px;">{r['article']} · {r['color']} · {r['gender']}</span>
+# ═════════════════════════════════════════════════════════════════════════════
+# 5.  Document renderer (HTML card)
+# ═════════════════════════════════════════════════════════════════════════════
+def render_document(completed: dict) -> str:
+    c = completed
+    issuer  = c.get("issuer", {})
+    client  = c.get("client", {})
+    lines   = c.get("lines", [])
+
+    alloc_html = ""
+    if c.get("allocation_required"):
+        alloc_html = f"""
+        <div class="alloc-badge">
+          🔖 מספר הקצאה: <strong>{c.get('allocation_number','—')}</strong>
         </div>"""
-    html += "</div>"
-    return html
 
+    line_rows = "".join(
+        f"<tr><td>{ln['description']}</td>"
+        f"<td>{ln['quantity']}</td>"
+        f"<td>₪{ln['unit_price']:,.2f}</td>"
+        f"<td>₪{ln['line_total']:,.2f}</td></tr>"
+        for ln in lines
+    )
 
-# ── Gradio handlers ───────────────────────────────────────────────────────────
-def text_search(text, category, gender, diversity):
-    if not text.strip():
-        return None, None, None, "<p style='color:red'>⚠️ Please enter a search query.</p>"
-    r = get_recommendations(text, category, gender, diversity)
-    imgs = [x["image"] for x in r]
-    while len(imgs) < 3: imgs.append(None)
-    return imgs[0], imgs[1], imgs[2], build_info_html(r)
+    vat_pct = int(round(c.get("vat_rate", 0) * 100))
 
+    return f"""
+<div dir="rtl" style="font-family:'Arial Hebrew',Arial,sans-serif;
+     background:#0f1117; color:#e8eaf6; border-radius:16px;
+     padding:28px 32px; max-width:680px; margin:0 auto;
+     border:1px solid #2a2d3e; box-shadow:0 4px 32px rgba(0,0,0,.4);">
 
-def image_search(image, category, gender, diversity):
-    if image is None:
-        return None, None, None, "<p style='color:red'>⚠️ Please upload an image.</p>"
-    r = get_recommendations(image, category, gender, diversity)
-    imgs = [x["image"] for x in r]
-    while len(imgs) < 3: imgs.append(None)
-    return imgs[0], imgs[1], imgs[2], build_info_html(r)
+  <!-- header -->
+  <div style="display:flex;justify-content:space-between;align-items:flex-start;
+       border-bottom:2px solid #0d9488;padding-bottom:16px;margin-bottom:20px;">
+    <div>
+      <div style="font-size:22px;font-weight:700;color:#0d9488;">
+        {c.get('doc_type_he','מסמך')}
+      </div>
+      <div style="font-size:13px;color:#9e9e9e;margin-top:4px;">
+        מס׳ {c.get('serial_number','')} &nbsp;|&nbsp; {c.get('issue_date','')}
+      </div>
+    </div>
+    <div style="text-align:left;">
+      <div style="font-size:15px;font-weight:600;">{issuer.get('name','')}</div>
+      <div style="font-size:12px;color:#9e9e9e;">ח.פ. {issuer.get('tax_id','')}</div>
+      <div style="font-size:12px;color:#9e9e9e;">
+        {'עוסק מורשה' if issuer.get('status')=='authorized_dealer' else 'עוסק פטור'}
+      </div>
+    </div>
+  </div>
 
+  <!-- client -->
+  <div style="background:#1a1d2e;border-radius:10px;padding:14px 18px;
+       margin-bottom:20px;font-size:14px;">
+    <span style="color:#9e9e9e;">לקוח: </span>
+    <strong>{client.get('name','')}</strong>
+    {'<span style="margin-right:10px;font-size:12px;color:#9e9e9e;">עסק</span>' if client.get('is_business') else ''}
+    {f'<span style="font-size:12px;color:#9e9e9e;"> · ח.פ. {client.get("tax_id","")}</span>' if client.get('tax_id') else ''}
+  </div>
 
-# ── UI ────────────────────────────────────────────────────────────────────────
-with gr.Blocks(theme=gr.themes.Soft(), title="Fashion Visual Search") as demo:
+  {alloc_html}
 
-    gr.Markdown("""
-    # 👗 Fashion Visual Search
-    **Find similar fashion items using AI-powered visual search**
-    
-    Describe what you're looking for *or* upload a photo of a fashion item.  
-    Powered by **CLIP** (OpenAI) · Cosine Similarity · 10,000 indexed products
-    """)
+  <!-- line items -->
+  <table style="width:100%;border-collapse:collapse;font-size:14px;
+         margin-bottom:18px;">
+    <thead>
+      <tr style="color:#0d9488;border-bottom:1px solid #2a2d3e;text-align:right;">
+        <th style="padding:6px 0;">שירות/מוצר</th>
+        <th style="padding:6px 8px;">כמות</th>
+        <th style="padding:6px 8px;">מחיר יחידה</th>
+        <th style="padding:6px 0;">סה"כ שורה</th>
+      </tr>
+    </thead>
+    <tbody style="color:#e8eaf6;">
+      {line_rows}
+    </tbody>
+  </table>
 
-    with gr.Row():
+  <!-- totals -->
+  <div style="border-top:1px solid #2a2d3e;padding-top:14px;
+       font-size:14px;text-align:left;">
+    <div style="display:flex;justify-content:space-between;margin-bottom:4px;">
+      <span style="color:#9e9e9e;">סכום לפני מע"מ</span>
+      <span>₪{c.get('subtotal',0):,.2f}</span>
+    </div>
+    <div style="display:flex;justify-content:space-between;margin-bottom:4px;">
+      <span style="color:#9e9e9e;">מע"מ {vat_pct}%</span>
+      <span>₪{c.get('vat_amount',0):,.2f}</span>
+    </div>
+    <div style="display:flex;justify-content:space-between;
+         font-size:18px;font-weight:700;color:#0d9488;margin-top:8px;">
+      <span>סה"כ לתשלום</span>
+      <span>₪{c.get('total',0):,.2f}</span>
+    </div>
+    <div style="font-size:12px;color:#9e9e9e;margin-top:8px;text-align:right;">
+      אמצעי תשלום: {core.PAYMENT_HE.get(c.get('payment_method',''),'—')}
+    </div>
+  </div>
+</div>"""
 
-        # ── LEFT: Inputs ──────────────────────────────────────────────────────
-        with gr.Column(scale=1, min_width=300):
 
-            with gr.Tab("📝 Text Search"):
-                text_input = gr.Textbox(
-                    placeholder="e.g. 'elegant women black handbag'",
-                    label="Describe the item you want",
-                    lines=2
-                )
-                text_btn = gr.Button("🔍 Search", variant="primary", size="lg")
+def render_recommendations(recs: list[dict]) -> str:
+    if not recs:
+        return ""
+    cards = []
+    for r in recs:
+        cards.append(f"""
+        <div style="background:#1a1d2e;border-radius:10px;padding:14px 16px;
+             border:1px solid #2a2d3e;font-size:13px;">
+          <div style="color:#0d9488;font-weight:600;margin-bottom:6px;">
+            {r['doc_type_he']} · {r['category']}
+          </div>
+          <div style="color:#e8eaf6;margin-bottom:4px;line-height:1.4;">
+            {r['raw_text'][:80]}{'…' if len(r['raw_text'])>80 else ''}
+          </div>
+          <div style="color:#9e9e9e;">
+            {r['client_name']} · ₪{r['total']:,.0f}
+          </div>
+        </div>""")
+
+    return f"""
+<div dir="rtl" style="font-family:Arial,sans-serif;max-width:680px;margin:16px auto 0;">
+  <div style="font-size:14px;color:#9e9e9e;margin-bottom:10px;">
+    🔍 3 קבלות דומות מהמאגר
+  </div>
+  <div style="display:grid;grid-template-columns:repeat(3,1fr);gap:12px;">
+    {''.join(cards)}
+  </div>
+</div>"""
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 6.  Gradio UI
+# ═════════════════════════════════════════════════════════════════════════════
+CSS = """
+:root {
+  --bg:      #0b0b0f;
+  --panel:   #111118;
+  --border:  #1e2130;
+  --teal:    #0d9488;
+  --text:    #e8eaf6;
+  --muted:   #9e9e9e;
+}
+html, body, .gradio-container {
+  background: var(--bg) !important;
+  color: var(--text);
+  font-family: Arial, 'Arial Hebrew', sans-serif;
+}
+.gr-button-primary {
+  background: var(--teal) !important;
+  border: none !important;
+}
+textarea, input[type=text] {
+  background: var(--panel) !important;
+  color: var(--text) !important;
+  border: 1px solid var(--border) !important;
+  border-radius: 8px !important;
+}
+.chat-bubble-user   { background: #1a2a3a !important; }
+.chat-bubble-bot    { background: #1a1d2e !important; }
+footer { display: none !important; }
+"""
+
+QUICK_STARTERS = [
+    ("💼 עוסק מורשה + לקוח עסקי גדול",
+     "חברת מעגל בע\"מ שילמה 36,500 ש\"ח על פרויקט אתר מלא. העברה בנקאית."),
+    ("🧾 עוסק פטור - שיעור פרטי",
+     "קיבלתי 220 שקל מדביר על שיעור שחייה פרטי, מזומן"),
+    ("📦 חשבונית מס - כמה פריטים",
+     "נועה כהן שילמה 2 * 350 ש\"ח ייעוץ עסקי + 180 ש\"ח הכנת מצגת"),
+]
+
+DEMO_ISSUER = {
+    "name":   "מים שקטים",
+    "tax_id": "962569844",
+    "status": "authorized_dealer",
+}
+
+def _run_pipeline(raw_text: str, chat_history: list,
+                  pending_parse: dict | None, answers: dict):
+    """
+    Main pipeline step.
+    Returns: (chat_history, doc_html, recs_html, pending_parse, answers)
+    """
+    _lazy_init()
+
+    # Step 1 — parse
+    if pending_parse is None:
+        parse = model_parse(raw_text)
+    else:
+        parse = pending_parse
+
+    # Step 2 — check for questions
+    questions = clarification_questions(parse, answers)
+    if questions:
+        q_text = "\n".join(f"• {q}" for q in questions)
+        chat_history = chat_history + [
+            {"role": "assistant",
+             "content": f"יש לי כמה שאלות לפני שאפיק את המסמך:\n\n{q_text}"}
+        ]
+        return chat_history, "", "", parse, answers
+
+    # Step 3 — apply answers + complete
+    final_parse = apply_answers(parse, answers)
+    try:
+        completed = core.complete(DEMO_ISSUER, final_parse, _STATE["rng"])
+    except Exception as e:
+        return (chat_history + [{"role": "assistant",
+                                 "content": f"שגיאה בעיבוד: {e}"}],
+                "", "", None, {})
+
+    # Step 4 — render
+    doc_html  = render_document(completed)
+    recs      = recommend(raw_text)
+    recs_html = render_recommendations(recs)
+
+    chat_history = chat_history + [
+        {"role": "assistant",
+         "content": "✅ המסמך הופק בהצלחה! ראה למטה."}
+    ]
+    return chat_history, doc_html, recs_html, None, {}
 
-            with gr.Tab("🖼️ Image Search"):
-                image_input = gr.Image(type="pil", label="Upload a fashion item photo")
-                image_btn = gr.Button("🔍 Find Similar Items", variant="primary", size="lg")
 
-            with gr.Accordion("⚙️ Filters & Options", open=False):
-                category_dd  = gr.Dropdown(CATEGORIES, value="All", label="Category")
-                gender_dd    = gr.Dropdown(GENDERS,    value="All", label="Gender")
-                diversity_cb = gr.Checkbox(label="🎨 Diversity mode (MMR)", value=False,
-                                           info="Returns more varied results")
+def _handle_answer(user_msg: str, chat_history: list,
+                   pending_parse: dict | None, answers: dict,
+                   raw_text: str):
+    """Parse a free-text answer and route back through pipeline."""
+    a = dict(answers)
+    low = user_msg.strip()
 
-        # ── RIGHT: Outputs ────────────────────────────────────────────────────
+    # simple intent detection for clarification answers
+    if any(w in low for w in ["חשבונית מס", "מס וקבלה", "מס/קבלה"]):
+        a["doc_type"] = low
+    elif "קבלה" in low:
+        a["doc_type"] = "receipt"
+    elif not a.get("client_name") and pending_parse and not pending_parse.get("client_name"):
+        a["client_name"] = user_msg.strip()
+
+    chat_history = chat_history + [{"role": "user", "content": user_msg}]
+    return _run_pipeline(raw_text, chat_history, pending_parse, a)
+
+
+# ── build UI ─────────────────────────────────────────────────────────────────
+with gr.Blocks(css=CSS, title="Text2Receipt") as demo:
+
+    gr.HTML("""
+    <div dir="rtl" style="text-align:center;padding:24px 0 8px;">
+      <div style="font-size:36px;margin-bottom:6px;">🧾</div>
+      <div style="font-size:28px;font-weight:800;color:#0d9488;">Text2Receipt</div>
+      <div style="font-size:14px;color:#9e9e9e;margin-top:4px;">
+        הערת הכנסה חופשית בעברית → מסמך פיסקלי ישראלי תקין
+      </div>
+    </div>""")
+
+    # state
+    st_parse   = gr.State(None)
+    st_answers = gr.State({})
+    st_raw     = gr.State("")
+
+    with gr.Row():
         with gr.Column(scale=2):
-            gr.Markdown("### 🎯 Top 3 Recommendations")
+            note_input = gr.Textbox(
+                label="הערת הכנסה (עברית חופשית)",
+                placeholder="לדוגמה: קיבלתי 1,200 ש\"ח ממשה כהן על ייעוץ עסקי",
+                lines=3, rtl=True,
+            )
             with gr.Row():
-                out1 = gr.Image(label="Match #1", show_label=True)
-                out2 = gr.Image(label="Match #2", show_label=True)
-                out3 = gr.Image(label="Match #3", show_label=True)
-            info_out = gr.HTML()
-
-    # ── Examples ──────────────────────────────────────────────────────────────
-    gr.Examples(
-        examples=[
-            ["elegant women black handbag"],
-            ["blue casual men shirt"],
-            ["sports running shoes"],
-            ["gold women watch"],
-            ["red summer dress women"],
-        ],
-        inputs=text_input,
-        label="💡 Try these examples (click to load, then Search)"
-    )
+                submit_btn = gr.Button("⚡ הפק מסמך", variant="primary")
+                clear_btn  = gr.Button("🗑 נקה")
 
-    gr.Markdown("""
-    ---
-    **How it works:** Your query is converted to a 512-dimensional CLIP embedding vector.  
-    Cosine similarity is then computed against all 10,000 indexed products to find the closest matches.
-    """)
-
-    # ── Wire up ───────────────────────────────────────────────────────────────
-    text_btn.click(
-        fn=text_search,
-        inputs=[text_input, category_dd, gender_dd, diversity_cb],
-        outputs=[out1, out2, out3, info_out]
+            gr.Markdown("**דוגמאות מהירות:**", rtl=True)
+            for label, example in QUICK_STARTERS:
+                gr.Button(label).click(
+                    fn=lambda ex=example: ex,
+                    outputs=note_input
+                )
+
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(
+                label="סוכן הבהרה",
+                type="messages",
+                rtl=True,
+                height=220,
+            )
+            answer_input = gr.Textbox(
+                label="תשובה לשאלת הסוכן",
+                placeholder="הקלד תשובה ולחץ Enter...",
+                visible=True, rtl=True,
+            )
+
+    doc_output  = gr.HTML(label="מסמך פיסקלי")
+    recs_output = gr.HTML(label="קבלות דומות")
+
+    # ── event wiring ──────────────────────────────────────────────────────────
+    def on_submit(raw, history, pending, answers):
+        history = history + [{"role": "user", "content": raw}]
+        return _run_pipeline(raw, history, None, {})
+
+    submit_btn.click(
+        fn=on_submit,
+        inputs=[note_input, chatbot, st_parse, st_answers],
+        outputs=[chatbot, doc_output, recs_output, st_parse, st_answers],
+    )
+    note_input.submit(
+        fn=on_submit,
+        inputs=[note_input, chatbot, st_parse, st_answers],
+        outputs=[chatbot, doc_output, recs_output, st_parse, st_answers],
+    )
+    answer_input.submit(
+        fn=_handle_answer,
+        inputs=[answer_input, chatbot, st_parse, st_answers, note_input],
+        outputs=[chatbot, doc_output, recs_output, st_parse, st_answers],
     )
-    image_btn.click(
-        fn=image_search,
-        inputs=[image_input, category_dd, gender_dd, diversity_cb],
-        outputs=[out1, out2, out3, info_out]
+    clear_btn.click(
+        fn=lambda: ([], "", "", None, {}, ""),
+        outputs=[chatbot, doc_output, recs_output, st_parse, st_answers, note_input],
     )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()