Update app.py

app.py

@@ -2,7 +2,6 @@
 # import json
 # import hashlib
 # import shutil
-# from io import BytesIO
 # from typing import List, Tuple
 
 # import gradio as gr
@@ -15,13 +14,22 @@
 # # ---------------- Config ----------------
 # OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
 # OPENROUTER_MODEL = "nvidia/nemotron-nano-12b-v2-vl:free"
-# EMBEDDING_MODEL_NAME = "paraphrase-MiniLM-L3-v2"  # lighter model, less RAM
+# EMBEDDING_MODEL_NAME = "paraphrase-MiniLM-L3-v2"
 # CACHE_DIR = "./cache"
-# SYSTEM_PROMPT = "You are a helpful assistant."
+# CHUNK_SIZE = 300        # words per chunk
+# CHUNK_OVERLAP = 50      # overlapping words between chunks
+# TOP_K = 4               # number of chunks to retrieve
+
+# SYSTEM_PROMPT = (
+#     "You are an expert document assistant. "
+#     "Answer questions using ONLY the provided context from the uploaded PDFs. "
+#     "Be concise, accurate, and cite which document your answer comes from. "
+#     "Always respond in plain text. Avoid markdown formatting."
+# )
 
 # os.makedirs(CACHE_DIR, exist_ok=True)
 
-# # Lazy loaded — model is NOT loaded at startup to avoid OOM on HF Spaces
+# # Lazy loaded to avoid OOM on HF Spaces
 # embedder = None
 
 # def get_embedder():
@@ -32,45 +40,77 @@
 #         print("Embedder loaded.")
 #     return embedder
 
-# DOCS: List[str] = []
-# FILENAMES: List[str] = []
+# # Global state
+# CHUNKS: List[str] = []
+# CHUNK_SOURCES: List[str] = []
+# CHUNK_PAGES: List[int] = []
 # EMBEDDINGS: np.ndarray = None
 # FAISS_INDEX = None
-# CURRENT_CACHE_KEY: str = ""
+# INDEXED_FILES: List[dict] = []
 
 
-# # ---------------- Cache cleanup (manual, no async loop) ----------------
+# # ---------------- Cache cleanup ----------------
 # def clear_old_cache():
 #     try:
 #         if os.path.exists(CACHE_DIR):
 #             shutil.rmtree(CACHE_DIR)
 #         os.makedirs(CACHE_DIR, exist_ok=True)
-#         print("Cache cleared.")
 #     except Exception as e:
 #         print(f"[Cache cleanup error] {e}")
 
 
-# # ---------------- PDF extraction ----------------
-# def extract_text_from_pdf(file_bytes: bytes) -> str:
+# # ---------------- PDF extraction with page tracking ----------------
+# def extract_pages_from_pdf(file_bytes: bytes) -> List[Tuple[int, str]]:
+#     """Returns list of (page_number, page_text)"""
 #     try:
 #         doc = fitz.open(stream=file_bytes, filetype="pdf")
-#         return "\n".join(page.get_text() for page in doc)
+#         pages = []
+#         for i, page in enumerate(doc):
+#             text = page.get_text().strip()
+#             if text:
+#                 pages.append((i + 1, text))
+#         return pages
 #     except Exception as e:
-#         return f"[PDF extraction error] {e}"
-
-
-# # ---------------- Cache + FAISS helpers ----------------
+#         return [(0, f"[PDF extraction error] {e}")]
+
+
+# # ---------------- Chunking strategy ----------------
+# def chunk_text(text: str, source: str, page: int,
+#                chunk_size: int = CHUNK_SIZE,
+#                overlap: int = CHUNK_OVERLAP) -> List[Tuple[str, str, int]]:
+#     """
+#     Splits text into overlapping word-level chunks.
+#     Returns list of (chunk_text, source, page)
+#     """
+#     words = text.split()
+#     chunks = []
+#     step = chunk_size - overlap
+#     for i in range(0, len(words), step):
+#         chunk = " ".join(words[i: i + chunk_size])
+#         if len(chunk.strip()) > 50:
+#             chunks.append((chunk, source, page))
+#         if i + chunk_size >= len(words):
+#             break
+#     return chunks
+
+
+# # ---------------- Cache helpers ----------------
 # def make_cache_key(files: List[Tuple[str, bytes]]) -> str:
 #     h = hashlib.sha256()
 #     for name, b in sorted(files, key=lambda x: x[0]):
 #         h.update(name.encode())
-#         h.update(str(len(b)).encode())
 #         h.update(hashlib.sha256(b).digest())
 #     return h.hexdigest()
 
-# def cache_save(cache_key: str, embeddings: np.ndarray, filenames: List[str]):
-#     np.savez_compressed(os.path.join(CACHE_DIR, f"{cache_key}.npz"),
-#                         embeddings=embeddings, filenames=np.array(filenames))
+# def cache_save(cache_key: str, embeddings: np.ndarray,
+#                chunks: List[str], sources: List[str], pages: List[int]):
+#     np.savez_compressed(
+#         os.path.join(CACHE_DIR, f"{cache_key}.npz"),
+#         embeddings=embeddings,
+#         chunks=np.array(chunks),
+#         sources=np.array(sources),
+#         pages=np.array(pages),
+#     )
 
 # def cache_load(cache_key: str):
 #     path = os.path.join(CACHE_DIR, f"{cache_key}.npz")
@@ -78,72 +118,74 @@
 #         return None
 #     try:
 #         data = np.load(path, allow_pickle=True)
-#         return data["embeddings"], data["filenames"].tolist()
+#         return (
+#             data["embeddings"],
+#             data["chunks"].tolist(),
+#             data["sources"].tolist(),
+#             data["pages"].tolist(),
+#         )
 #     except:
 #         return None
 
+
+# # ---------------- FAISS ----------------
 # def build_faiss(emb: np.ndarray):
 #     global FAISS_INDEX
 #     if emb is None or len(emb) == 0:
 #         FAISS_INDEX = None
-#         return None
+#         return
 #     emb = emb.astype("float32")
 #     index = faiss.IndexFlatL2(emb.shape[1])
 #     index.add(emb)
 #     FAISS_INDEX = index
-#     return index
 
-# def search(query: str, k: int = 3):
-#     if FAISS_INDEX is None:
+# def search(query: str, k: int = TOP_K):
+#     if FAISS_INDEX is None or not CHUNKS:
 #         return []
 #     q_emb = get_embedder().encode([query], convert_to_numpy=True).astype("float32")
 #     D, I = FAISS_INDEX.search(q_emb, k)
-#     return [
-#         {"index": int(i), "distance": float(d), "text": DOCS[i], "source": FILENAMES[i]}
-#         for d, i in zip(D[0], I[0]) if i >= 0
-#     ]
+#     results = []
+#     for d, i in zip(D[0], I[0]):
+#         if i >= 0 and i < len(CHUNKS):
+#             results.append({
+#                 "text": CHUNKS[i],
+#                 "source": CHUNK_SOURCES[i],
+#                 "page": CHUNK_PAGES[i],
+#                 "distance": float(d),
+#             })
+#     return results
 
 
 # # ---------------- OpenRouter API ----------------
-# def call_openrouter(prompt: str):
+# def call_openrouter(messages: list) -> str:
 #     if not OPENROUTER_API_KEY:
-#         return "[OpenRouter error] Missing OPENROUTER_API_KEY."
+#         return "Error: OPENROUTER_API_KEY is not set. Please add it in HF Space secrets."
 
 #     url = "https://openrouter.ai/api/v1/chat/completions"
 #     headers = {
 #         "Authorization": f"Bearer {OPENROUTER_API_KEY}",
 #         "Content-Type": "application/json",
 #     }
-
 #     payload = {
 #         "model": OPENROUTER_MODEL,
-#         "messages": [
-#             {"role": "system",
-#              "content": SYSTEM_PROMPT + " Always respond in plain text. Avoid markdown."},
-#             {"role": "user", "content": prompt},
-#         ],
+#         "messages": [{"role": "system", "content": SYSTEM_PROMPT}] + messages,
 #     }
 
 #     try:
 #         r = requests.post(url, headers=headers, json=payload, timeout=60)
 #         r.raise_for_status()
 #         obj = r.json()
-
 #         if "choices" in obj and obj["choices"]:
-#             text = obj["choices"][0]["message"]["content"]
-#             return text.strip().replace("```", "")
-#         return "[Unexpected OpenRouter response]"
+#             return obj["choices"][0]["message"]["content"].strip().replace("```", "")
+#         return "[Unexpected response from API]"
 #     except Exception as e:
-#         return f"[OpenRouter request error] {e}"
+#         return f"[OpenRouter error] {e}"
 
 
-# # ---------- Helper to read bytes from various Gradio file shapes ----------
+# # ---------------- File bytes reader ----------------
 # def read_file_bytes(f) -> Tuple[str, bytes]:
-#     # tuple (name, bytes)
 #     if isinstance(f, tuple) and len(f) == 2 and isinstance(f[1], (bytes, bytearray)):
 #         return f[0], bytes(f[1])
-
-#     # dict-like
 #     if isinstance(f, dict):
 #         name = f.get("name") or f.get("filename") or "uploaded"
 #         data = f.get("data") or f.get("content") or f.get("value") or f.get("file")
@@ -158,16 +200,12 @@
 #         if tmp_path and isinstance(tmp_path, str) and os.path.exists(tmp_path):
 #             with open(tmp_path, "rb") as fh:
 #                 return os.path.basename(tmp_path), fh.read()
-
-#     # file-like object with read()
 #     if hasattr(f, "name") and hasattr(f, "read"):
 #         try:
 #             name = os.path.basename(f.name) if getattr(f, "name", None) else "uploaded"
 #             return name, f.read()
 #         except Exception:
 #             pass
-
-#     # NamedString-like: has .name and .value
 #     if hasattr(f, "name") and hasattr(f, "value"):
 #         name = os.path.basename(getattr(f, "name") or "uploaded")
 #         v = getattr(f, "value")
@@ -175,23 +213,19 @@
 #             return name, bytes(v)
 #         if isinstance(v, str):
 #             return name, v.encode("utf-8")
-
-#     # string path
 #     if isinstance(f, str) and os.path.exists(f):
 #         with open(f, "rb") as fh:
 #             return os.path.basename(f), fh.read()
-
 #     raise ValueError(f"Unsupported file object type: {type(f)}")
 
 
-# # ---------------- PDF Upload & Index ----------------
+# # ---------------- Upload & Index ----------------
 # def upload_and_index(files):
-#     global DOCS, FILENAMES, EMBEDDINGS, CURRENT_CACHE_KEY
+#     global CHUNKS, CHUNK_SOURCES, CHUNK_PAGES, EMBEDDINGS, INDEXED_FILES
 
 #     if not files:
-#         return "No PDF uploaded.", ""
+#         return "No files uploaded.", "No files indexed yet."
 
-#     # Clear old cache on every new upload to free up space
 #     clear_old_cache()
 
 #     processed = []
@@ -203,77 +237,300 @@
 #             name, b = read_file_bytes(f)
 #             processed.append((name, b))
 #     except ValueError as e:
-#         return f"Upload error: {e}", ""
-
-#     preview = [{"name": n, "size": len(b)} for n, b in processed]
+#         return f"Upload error: {e}", "No files indexed yet."
 
 #     cache_key = make_cache_key(processed)
-#     CURRENT_CACHE_KEY = cache_key
-
 #     cached = cache_load(cache_key)
+
 #     if cached:
-#         EMBEDDINGS, FILENAMES = cached
+#         EMBEDDINGS, CHUNKS, CHUNK_SOURCES, CHUNK_PAGES = cached
 #         EMBEDDINGS = np.array(EMBEDDINGS)
-#         DOCS = [extract_text_from_pdf(b) for _, b in processed]
 #         build_faiss(EMBEDDINGS)
-#         return f"Loaded cached embeddings ({len(FILENAMES)} PDFs).", json.dumps(preview)
-
-#     # Extract text
-#     DOCS = [extract_text_from_pdf(b) for _, b in processed]
-#     FILENAMES = [n for n, _ in processed]
-
-#     # Embed — lazy loads the model here, not at startup
-#     EMBEDDINGS = get_embedder().encode(DOCS, convert_to_numpy=True).astype("float32")
-#     cache_save(cache_key, EMBEDDINGS, FILENAMES)
+#         INDEXED_FILES = [{"name": n, "size_kb": round(len(b)/1024, 1)} for n, b in processed]
+#         return (
+#             f"Loaded from cache — {len(CHUNKS)} chunks across {len(processed)} PDF(s).",
+#             _render_file_list(INDEXED_FILES)
+#         )
+
+#     all_chunks, all_sources, all_pages = [], [], []
+#     INDEXED_FILES = []
+
+#     for name, b in processed:
+#         pages = extract_pages_from_pdf(b)
+#         file_chunks = 0
+#         for page_num, page_text in pages:
+#             for chunk, src, pg in chunk_text(page_text, name, page_num):
+#                 all_chunks.append(chunk)
+#                 all_sources.append(src)
+#                 all_pages.append(pg)
+#                 file_chunks += 1
+#         INDEXED_FILES.append({
+#             "name": name,
+#             "size_kb": round(len(b) / 1024, 1),
+#             "pages": len(pages),
+#             "chunks": file_chunks,
+#         })
+
+#     CHUNKS = all_chunks
+#     CHUNK_SOURCES = all_sources
+#     CHUNK_PAGES = all_pages
+
+#     if not CHUNKS:
+#         return "Could not extract any text from the PDFs.", "No files indexed."
+
+#     EMBEDDINGS = get_embedder().encode(CHUNKS, convert_to_numpy=True).astype("float32")
+#     cache_save(cache_key, EMBEDDINGS, CHUNKS, CHUNK_SOURCES, CHUNK_PAGES)
 #     build_faiss(EMBEDDINGS)
 
-#     return f"Uploaded + indexed {len(DOCS)} PDFs.", json.dumps(preview)
-
-
-# # ---------------- Question Answering ----------------
-# def ask(question: str):
-#     if not question:
-#         return "Please enter a question."
-#     if not DOCS:
-#         return "No PDFs indexed. Please upload a PDF first."
-
-#     results = search(question)
-
-#     if not results:
-#         return "No relevant text found in the uploaded PDFs."
-
-#     context = "\n".join(
-#         f"Source: {r['source']}\n\n{r['text'][:15000]}\n---\n"
-#         for r in results
+#     return (
+#         f"Indexed {len(processed)} PDF(s) — {len(CHUNKS)} chunks ready.",
+#         _render_file_list(INDEXED_FILES)
 #     )
 
-#     prompt = f"Use this context to answer briefly:\n\n{context}\nQuestion: {question}\nAnswer:"
-#     return call_openrouter(prompt)
+# def _render_file_list(files: List[dict]) -> str:
+#     if not files:
+#         return "No files indexed yet."
+#     lines = []
+#     for f in files:
+#         parts = [f"📄 {f['name']} ({f['size_kb']} KB)"]
+#         if "pages" in f:
+#             parts.append(f"{f['pages']} pages")
+#         if "chunks" in f:
+#             parts.append(f"{f['chunks']} chunks")
+#         lines.append("  |  ".join(parts))
+#     return "\n".join(lines)
+
+
+# # ---------------- Chat ----------------
+# def chat(message: str, history: list):
+#     if not message.strip():
+#         return "", history
+
+#     if not CHUNKS:
+#         history.append((message, "No PDFs indexed yet. Please upload a PDF first."))
+#         return "", history
+
+#     results = search(message)
+#     if not results:
+#         history.append((message, "No relevant content found in the uploaded PDFs."))
+#         return "", history
+
+#     context_parts = []
+#     sources_used = []
+#     for r in results:
+#         context_parts.append(f"[From: {r['source']}, Page {r['page']}]\n{r['text']}")
+#         source_ref = f"{r['source']} (p.{r['page']})"
+#         if source_ref not in sources_used:
+#             sources_used.append(source_ref)
+
+#     context = "\n\n---\n\n".join(context_parts)
+
+#     # Multi-turn: include last 4 exchanges
+#     messages = []
+#     for user_msg, bot_msg in history[-4:]:
+#         messages.append({"role": "user", "content": user_msg})
+#         messages.append({"role": "assistant", "content": bot_msg})
+
+#     messages.append({
+#         "role": "user",
+#         "content": f"Context from PDFs:\n\n{context}\n\nQuestion: {message}"
+#     })
+
+#     answer = call_openrouter(messages)
+
+#     if sources_used:
+#         answer += f"\n\nSources: {', '.join(sources_used)}"
+
+#     history.append((message, answer))
+#     return "", history
+
+
+# def clear_chat():
+#     return []
+
+
+# # ---------------- Custom CSS ----------------
+# custom_css = """
+# @import url('https://fonts.googleapis.com/css2?family=Syne:wght@400;600;700;800&family=DM+Mono:wght@300;400;500&display=swap');
+
+# :root {
+#     --bg: #0d0f12;
+#     --surface: #13161b;
+#     --surface2: #1a1e26;
+#     --border: #252a35;
+#     --accent: #4fffb0;
+#     --accent2: #00c2ff;
+#     --text: #e8eaf0;
+#     --muted: #6b7280;
+# }
+
+# body, .gradio-container {
+#     background: var(--bg) !important;
+#     font-family: 'DM Mono', monospace !important;
+#     color: var(--text) !important;
+# }
+
+# .gradio-container {
+#     max-width: 1100px !important;
+#     margin: 0 auto !important;
+# }
+
+# .app-header {
+#     text-align: center;
+#     padding: 36px 0 28px;
+#     border-bottom: 1px solid var(--border);
+#     margin-bottom: 28px;
+# }
+
+# .app-header h1 {
+#     font-family: 'Syne', sans-serif;
+#     font-size: 2.4rem;
+#     font-weight: 800;
+#     background: linear-gradient(135deg, var(--accent), var(--accent2));
+#     -webkit-background-clip: text;
+#     -webkit-text-fill-color: transparent;
+#     background-clip: text;
+#     margin: 0 0 6px;
+#     letter-spacing: -1px;
+# }
+
+# .app-header p {
+#     color: var(--muted);
+#     font-size: 0.85rem;
+#     margin: 0;
+#     font-family: 'DM Mono', monospace;
+# }
+
+# .section-label {
+#     font-family: 'Syne', sans-serif;
+#     font-size: 0.7rem;
+#     font-weight: 700;
+#     letter-spacing: 2.5px;
+#     text-transform: uppercase;
+#     color: var(--accent);
+#     margin-bottom: 10px;
+# }
+
+# textarea, input[type="text"] {
+#     background: var(--surface2) !important;
+#     border: 1px solid var(--border) !important;
+#     border-radius: 8px !important;
+#     color: var(--text) !important;
+#     font-family: 'DM Mono', monospace !important;
+#     font-size: 0.87rem !important;
+# }
+# textarea:focus, input[type="text"]:focus {
+#     border-color: var(--accent) !important;
+#     box-shadow: 0 0 0 2px rgba(79,255,176,0.08) !important;
+# }
+
+# .footer-note {
+#     text-align: center;
+#     margin-top: 28px;
+#     color: #2d3340;
+#     font-size: 0.72rem;
+#     font-family: 'DM Mono', monospace;
+#     letter-spacing: 0.5px;
+# }
+# """
 
 
 # # ---------------- Gradio UI ----------------
-# with gr.Blocks(title="PDF RAG Bot") as demo:
-#     gr.Markdown("# 📄 PDF-Only RAG Bot\nUpload PDFs → Ask Questions → AI Answers from PDF content.")
-
-#     file_input = gr.File(label="Upload PDF files", file_count="multiple", file_types=[".pdf"])
-#     upload_btn = gr.Button("Upload & Index")
-#     status = gr.Textbox(label="Status", interactive=False)
-#     preview = gr.Textbox(label="Upload preview (JSON)", interactive=False)
-
-#     upload_btn.click(upload_and_index, inputs=[file_input], outputs=[status, preview])
-
-#     gr.Markdown("### Ask a Question")
-#     q = gr.Textbox(label="Your question", lines=3)
-#     ask_btn = gr.Button("Ask PDF Bot")
-#     answer = gr.Textbox(label="Answer", lines=15)
+# with gr.Blocks(
+#     title="PDF RAG Bot",
+#     css=custom_css,
+#     theme=gr.themes.Base(
+#         primary_hue="emerald",
+#         neutral_hue="slate",
+#     )
+# ) as demo:
+
+#     gr.HTML("""
+#     <div class="app-header">
+#         <h1>⚡ PDF RAG Bot</h1>
+#         <p>Upload PDFs &nbsp;·&nbsp; Semantic chunking &nbsp;·&nbsp; Ask anything &nbsp;·&nbsp; AI answers with page sources</p>
+#     </div>
+#     """)
+
+#     with gr.Row(equal_height=False):
+
+#         # ── Left: Upload panel ──
+#         with gr.Column(scale=1, min_width=280):
+#             gr.HTML('<div class="section-label">📂 Document Upload</div>')
+
+#             file_input = gr.File(
+#                 label="Drop PDF files here",
+#                 file_count="multiple",
+#                 file_types=[".pdf"],
+#             )
+#             upload_btn = gr.Button("⚡  Upload & Index", variant="primary", size="lg")
+
+#             status = gr.Textbox(
+#                 label="Status",
+#                 interactive=False,
+#                 lines=2,
+#             )
+#             file_list = gr.Textbox(
+#                 label="Indexed Files",
+#                 interactive=False,
+#                 lines=6,
+#                 placeholder="No files indexed yet...",
+#             )
+
+#         # ── Right: Chat panel ──
+#         with gr.Column(scale=2):
+#             gr.HTML('<div class="section-label">💬 Chat with your PDFs</div>')
+
+#             chatbot = gr.Chatbot(
+#                 label="",
+#                 height=430,
+#                 bubble_full_width=False,
+#                 show_label=False,
+#                 placeholder="Upload a PDF and start asking questions...",
+#             )
+
+#             with gr.Row():
+#                 question = gr.Textbox(
+#                     label="",
+#                     placeholder="Ask something about your documents...",
+#                     lines=2,
+#                     scale=5,
+#                     show_label=False,
+#                 )
+#                 with gr.Column(scale=1, min_width=90):
+#                     send_btn = gr.Button("Send ➤", variant="primary")
+#                     clear_btn = gr.Button("Clear", variant="secondary")
+
+#     gr.HTML("""
+#     <div class="footer-note">
+#         Powered by OpenRouter &nbsp;·&nbsp; nvidia/nemotron-nano-12b &nbsp;·&nbsp;
+#         sentence-transformers &nbsp;·&nbsp; FAISS vector search
+#     </div>
+#     """)
+
+#     # Events
+#     upload_btn.click(
+#         upload_and_index,
+#         inputs=[file_input],
+#         outputs=[status, file_list],
+#     )
+#     send_btn.click(
+#         chat,
+#         inputs=[question, chatbot],
+#         outputs=[question, chatbot],
+#     )
+#     question.submit(
+#         chat,
+#         inputs=[question, chatbot],
+#         outputs=[question, chatbot],
+#     )
+#     clear_btn.click(clear_chat, outputs=[chatbot])
 
-#     ask_btn.click(ask, inputs=[q], outputs=[answer])
 
 # if __name__ == "__main__":
 #     demo.launch(server_name="0.0.0.0", server_port=7860, debug=True)
 
 import os
-import json
 import hashlib
 import shutil
 from typing import List, Tuple
@@ -290,31 +547,27 @@ OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
 OPENROUTER_MODEL = "nvidia/nemotron-nano-12b-v2-vl:free"
 EMBEDDING_MODEL_NAME = "paraphrase-MiniLM-L3-v2"
 CACHE_DIR = "./cache"
-CHUNK_SIZE = 300        # words per chunk
-CHUNK_OVERLAP = 50      # overlapping words between chunks
-TOP_K = 4               # number of chunks to retrieve
+CHUNK_SIZE = 300
+CHUNK_OVERLAP = 50
+TOP_K = 4
 
 SYSTEM_PROMPT = (
     "You are an expert document assistant. "
     "Answer questions using ONLY the provided context from the uploaded PDFs. "
-    "Be concise, accurate, and cite which document your answer comes from. "
+    "Be concise, accurate, and mention which document your answer comes from. "
     "Always respond in plain text. Avoid markdown formatting."
 )
 
 os.makedirs(CACHE_DIR, exist_ok=True)
 
-# Lazy loaded to avoid OOM on HF Spaces
 embedder = None
 
 def get_embedder():
     global embedder
     if embedder is None:
-        print("Loading embedder model...")
         embedder = SentenceTransformer(EMBEDDING_MODEL_NAME)
-        print("Embedder loaded.")
     return embedder
 
-# Global state
 CHUNKS: List[str] = []
 CHUNK_SOURCES: List[str] = []
 CHUNK_PAGES: List[int] = []
@@ -323,19 +576,16 @@ FAISS_INDEX = None
 INDEXED_FILES: List[dict] = []
 
 
-# ---------------- Cache cleanup ----------------
 def clear_old_cache():
     try:
         if os.path.exists(CACHE_DIR):
             shutil.rmtree(CACHE_DIR)
         os.makedirs(CACHE_DIR, exist_ok=True)
     except Exception as e:
-        print(f"[Cache cleanup error] {e}")
+        print(f"[Cache error] {e}")
 
 
-# ---------------- PDF extraction with page tracking ----------------
 def extract_pages_from_pdf(file_bytes: bytes) -> List[Tuple[int, str]]:
-    """Returns list of (page_number, page_text)"""
     try:
         doc = fitz.open(stream=file_bytes, filetype="pdf")
         pages = []
@@ -345,30 +595,22 @@ def extract_pages_from_pdf(file_bytes: bytes) -> List[Tuple[int, str]]:
                 pages.append((i + 1, text))
         return pages
     except Exception as e:
-        return [(0, f"[PDF extraction error] {e}")]
+        return [(0, f"[PDF error] {e}")]
 
 
-# ---------------- Chunking strategy ----------------
-def chunk_text(text: str, source: str, page: int,
-               chunk_size: int = CHUNK_SIZE,
-               overlap: int = CHUNK_OVERLAP) -> List[Tuple[str, str, int]]:
-    """
-    Splits text into overlapping word-level chunks.
-    Returns list of (chunk_text, source, page)
-    """
+def chunk_text(text: str, source: str, page: int) -> List[Tuple[str, str, int]]:
     words = text.split()
     chunks = []
-    step = chunk_size - overlap
+    step = CHUNK_SIZE - CHUNK_OVERLAP
     for i in range(0, len(words), step):
-        chunk = " ".join(words[i: i + chunk_size])
+        chunk = " ".join(words[i: i + CHUNK_SIZE])
         if len(chunk.strip()) > 50:
             chunks.append((chunk, source, page))
-        if i + chunk_size >= len(words):
+        if i + CHUNK_SIZE >= len(words):
             break
     return chunks
 
 
-# ---------------- Cache helpers ----------------
 def make_cache_key(files: List[Tuple[str, bytes]]) -> str:
     h = hashlib.sha256()
     for name, b in sorted(files, key=lambda x: x[0]):
@@ -376,8 +618,7 @@ def make_cache_key(files: List[Tuple[str, bytes]]) -> str:
         h.update(hashlib.sha256(b).digest())
     return h.hexdigest()
 
-def cache_save(cache_key: str, embeddings: np.ndarray,
-               chunks: List[str], sources: List[str], pages: List[int]):
+def cache_save(cache_key, embeddings, chunks, sources, pages):
     np.savez_compressed(
         os.path.join(CACHE_DIR, f"{cache_key}.npz"),
         embeddings=embeddings,
@@ -386,24 +627,18 @@ def cache_save(cache_key: str, embeddings: np.ndarray,
         pages=np.array(pages),
     )
 
-def cache_load(cache_key: str):
+def cache_load(cache_key):
     path = os.path.join(CACHE_DIR, f"{cache_key}.npz")
     if not os.path.exists(path):
         return None
     try:
         data = np.load(path, allow_pickle=True)
-        return (
-            data["embeddings"],
-            data["chunks"].tolist(),
-            data["sources"].tolist(),
-            data["pages"].tolist(),
-        )
+        return data["embeddings"], data["chunks"].tolist(), data["sources"].tolist(), data["pages"].tolist()
     except:
         return None
 
 
-# ---------------- FAISS ----------------
-def build_faiss(emb: np.ndarray):
+def build_faiss(emb):
     global FAISS_INDEX
     if emb is None or len(emb) == 0:
         FAISS_INDEX = None
@@ -413,50 +648,35 @@ def build_faiss(emb: np.ndarray):
     index.add(emb)
     FAISS_INDEX = index
 
-def search(query: str, k: int = TOP_K):
+def search(query: str):
     if FAISS_INDEX is None or not CHUNKS:
         return []
     q_emb = get_embedder().encode([query], convert_to_numpy=True).astype("float32")
-    D, I = FAISS_INDEX.search(q_emb, k)
+    D, I = FAISS_INDEX.search(q_emb, TOP_K)
     results = []
     for d, i in zip(D[0], I[0]):
-        if i >= 0 and i < len(CHUNKS):
-            results.append({
-                "text": CHUNKS[i],
-                "source": CHUNK_SOURCES[i],
-                "page": CHUNK_PAGES[i],
-                "distance": float(d),
-            })
+        if 0 <= i < len(CHUNKS):
+            results.append({"text": CHUNKS[i], "source": CHUNK_SOURCES[i], "page": CHUNK_PAGES[i], "distance": float(d)})
     return results
 
 
-# ---------------- OpenRouter API ----------------
 def call_openrouter(messages: list) -> str:
     if not OPENROUTER_API_KEY:
-        return "Error: OPENROUTER_API_KEY is not set. Please add it in HF Space secrets."
-
+        return "Error: OPENROUTER_API_KEY not set. Add it in HF Space secrets."
     url = "https://openrouter.ai/api/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-        "Content-Type": "application/json",
-    }
-    payload = {
-        "model": OPENROUTER_MODEL,
-        "messages": [{"role": "system", "content": SYSTEM_PROMPT}] + messages,
-    }
-
+    headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json"}
+    payload = {"model": OPENROUTER_MODEL, "messages": [{"role": "system", "content": SYSTEM_PROMPT}] + messages}
     try:
         r = requests.post(url, headers=headers, json=payload, timeout=60)
         r.raise_for_status()
         obj = r.json()
         if "choices" in obj and obj["choices"]:
             return obj["choices"][0]["message"]["content"].strip().replace("```", "")
-        return "[Unexpected response from API]"
+        return "[Unexpected API response]"
     except Exception as e:
         return f"[OpenRouter error] {e}"
 
 
-# ---------------- File bytes reader ----------------
 def read_file_bytes(f) -> Tuple[str, bytes]:
     if isinstance(f, tuple) and len(f) == 2 and isinstance(f[1], (bytes, bytearray)):
         return f[0], bytes(f[1])
@@ -466,42 +686,34 @@ def read_file_bytes(f) -> Tuple[str, bytes]:
         if isinstance(data, (bytes, bytearray)):
             return name, bytes(data)
         if isinstance(data, str):
-            try:
-                return name, data.encode("utf-8")
-            except Exception:
-                pass
-        tmp_path = f.get("tmp_path") or f.get("path") or f.get("file")
-        if tmp_path and isinstance(tmp_path, str) and os.path.exists(tmp_path):
-            with open(tmp_path, "rb") as fh:
-                return os.path.basename(tmp_path), fh.read()
+            try: return name, data.encode("utf-8")
+            except: pass
+        tmp = f.get("tmp_path") or f.get("path") or f.get("file")
+        if tmp and isinstance(tmp, str) and os.path.exists(tmp):
+            with open(tmp, "rb") as fh:
+                return os.path.basename(tmp), fh.read()
     if hasattr(f, "name") and hasattr(f, "read"):
         try:
             name = os.path.basename(f.name) if getattr(f, "name", None) else "uploaded"
             return name, f.read()
-        except Exception:
-            pass
+        except: pass
     if hasattr(f, "name") and hasattr(f, "value"):
         name = os.path.basename(getattr(f, "name") or "uploaded")
         v = getattr(f, "value")
-        if isinstance(v, (bytes, bytearray)):
-            return name, bytes(v)
-        if isinstance(v, str):
-            return name, v.encode("utf-8")
+        if isinstance(v, (bytes, bytearray)): return name, bytes(v)
+        if isinstance(v, str): return name, v.encode("utf-8")
     if isinstance(f, str) and os.path.exists(f):
         with open(f, "rb") as fh:
             return os.path.basename(f), fh.read()
-    raise ValueError(f"Unsupported file object type: {type(f)}")
+    raise ValueError(f"Unsupported file type: {type(f)}")
 
 
-# ---------------- Upload & Index ----------------
 def upload_and_index(files):
     global CHUNKS, CHUNK_SOURCES, CHUNK_PAGES, EMBEDDINGS, INDEXED_FILES
-
     if not files:
-        return "No files uploaded.", "No files indexed yet."
+        return _status_html("warning", "No files selected. Please upload at least one PDF."), _file_cards([])
 
     clear_old_cache()
-
     processed = []
     if not isinstance(files, (list, tuple)):
         files = [files]
@@ -511,7 +723,7 @@ def upload_and_index(files):
             name, b = read_file_bytes(f)
             processed.append((name, b))
     except ValueError as e:
-        return f"Upload error: {e}", "No files indexed yet."
+        return _status_html("error", f"Upload error: {e}"), _file_cards([])
 
     cache_key = make_cache_key(processed)
     cached = cache_load(cache_key)
@@ -522,8 +734,8 @@ def upload_and_index(files):
         build_faiss(EMBEDDINGS)
         INDEXED_FILES = [{"name": n, "size_kb": round(len(b)/1024, 1)} for n, b in processed]
         return (
-            f"Loaded from cache — {len(CHUNKS)} chunks across {len(processed)} PDF(s).",
-            _render_file_list(INDEXED_FILES)
+            _status_html("success", f"Loaded from cache — {len(CHUNKS)} chunks across {len(processed)} PDF(s). Ready to chat!"),
+            _file_cards(INDEXED_FILES)
         )
 
     all_chunks, all_sources, all_pages = [], [], []
@@ -538,82 +750,86 @@ def upload_and_index(files):
                 all_sources.append(src)
                 all_pages.append(pg)
                 file_chunks += 1
-        INDEXED_FILES.append({
-            "name": name,
-            "size_kb": round(len(b) / 1024, 1),
-            "pages": len(pages),
-            "chunks": file_chunks,
-        })
+        INDEXED_FILES.append({"name": name, "size_kb": round(len(b)/1024, 1), "pages": len(pages), "chunks": file_chunks})
 
     CHUNKS = all_chunks
     CHUNK_SOURCES = all_sources
     CHUNK_PAGES = all_pages
 
     if not CHUNKS:
-        return "Could not extract any text from the PDFs.", "No files indexed."
+        return _status_html("error", "Could not extract text from the uploaded PDFs."), _file_cards([])
 
     EMBEDDINGS = get_embedder().encode(CHUNKS, convert_to_numpy=True).astype("float32")
     cache_save(cache_key, EMBEDDINGS, CHUNKS, CHUNK_SOURCES, CHUNK_PAGES)
     build_faiss(EMBEDDINGS)
 
     return (
-        f"Indexed {len(processed)} PDF(s) — {len(CHUNKS)} chunks ready.",
-        _render_file_list(INDEXED_FILES)
+        _status_html("success", f"Successfully indexed {len(processed)} PDF(s) → {len(CHUNKS)} semantic chunks ready!"),
+        _file_cards(INDEXED_FILES)
     )
 
-def _render_file_list(files: List[dict]) -> str:
+
+def _status_html(kind: str, msg: str) -> str:
+    colors = {
+        "success": ("#1a3a2a", "#4ade80", "✦"),
+        "warning": ("#3a2e1a", "#fbbf24", "⚠"),
+        "error":   ("#3a1a1a", "#f87171", "✕"),
+    }
+    bg, color, icon = colors.get(kind, colors["success"])
+    return f"""<div style="background:{bg};border:1px solid {color}33;border-radius:10px;padding:12px 16px;font-family:'Courier Prime',monospace;font-size:0.85rem;color:{color};display:flex;align-items:center;gap:10px;"><span style="font-size:1rem">{icon}</span>{msg}</div>"""
+
+
+def _file_cards(files: List[dict]) -> str:
     if not files:
-        return "No files indexed yet."
-    lines = []
+        return """<div style="font-family:'Courier Prime',monospace;color:#6b7280;font-size:0.8rem;text-align:center;padding:20px 0;">No files indexed yet</div>"""
+    cards = []
     for f in files:
-        parts = [f"📄 {f['name']} ({f['size_kb']} KB)"]
-        if "pages" in f:
-            parts.append(f"{f['pages']} pages")
-        if "chunks" in f:
-            parts.append(f"{f['chunks']} chunks")
-        lines.append("  |  ".join(parts))
-    return "\n".join(lines)
+        name = f["name"]
+        size = f.get("size_kb", "?")
+        pages = f.get("pages", "?")
+        chunks = f.get("chunks", "?")
+        cards.append(f"""
+        <div style="background:#1c1a16;border:1px solid #3a3020;border-radius:10px;padding:12px 14px;margin-bottom:8px;transition:border-color 0.2s;">
+          <div style="font-family:'Playfair Display',serif;font-size:0.9rem;color:#f5e6c8;font-weight:600;margin-bottom:6px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;">📄 {name}</div>
+          <div style="display:flex;gap:8px;flex-wrap:wrap;">
+            <span style="background:#2a2218;border:1px solid #4a3a20;border-radius:20px;padding:2px 10px;font-size:0.72rem;color:#c9a85c;font-family:'Courier Prime',monospace;">{size} KB</span>
+            <span style="background:#2a2218;border:1px solid #4a3a20;border-radius:20px;padding:2px 10px;font-size:0.72rem;color:#c9a85c;font-family:'Courier Prime',monospace;">{pages} pages</span>
+            <span style="background:#2a2218;border:1px solid #4a3a20;border-radius:20px;padding:2px 10px;font-size:0.72rem;color:#c9a85c;font-family:'Courier Prime',monospace;">{chunks} chunks</span>
+          </div>
+        </div>""")
+    return "".join(cards)
 
 
-# ---------------- Chat ----------------
 def chat(message: str, history: list):
     if not message.strip():
         return "", history
-
     if not CHUNKS:
-        history.append((message, "No PDFs indexed yet. Please upload a PDF first."))
+        history.append((message, "Please upload and index a PDF first before asking questions."))
         return "", history
 
     results = search(message)
     if not results:
-        history.append((message, "No relevant content found in the uploaded PDFs."))
+        history.append((message, "No relevant content found in the uploaded PDFs for that question."))
         return "", history
 
     context_parts = []
     sources_used = []
     for r in results:
         context_parts.append(f"[From: {r['source']}, Page {r['page']}]\n{r['text']}")
-        source_ref = f"{r['source']} (p.{r['page']})"
-        if source_ref not in sources_used:
-            sources_used.append(source_ref)
+        ref = f"{r['source']} (p.{r['page']})"
+        if ref not in sources_used:
+            sources_used.append(ref)
 
     context = "\n\n---\n\n".join(context_parts)
-
-    # Multi-turn: include last 4 exchanges
     messages = []
-    for user_msg, bot_msg in history[-4:]:
-        messages.append({"role": "user", "content": user_msg})
-        messages.append({"role": "assistant", "content": bot_msg})
-
-    messages.append({
-        "role": "user",
-        "content": f"Context from PDFs:\n\n{context}\n\nQuestion: {message}"
-    })
+    for u, b in history[-4:]:
+        messages.append({"role": "user", "content": u})
+        messages.append({"role": "assistant", "content": b})
+    messages.append({"role": "user", "content": f"Context:\n\n{context}\n\nQuestion: {message}"})
 
     answer = call_openrouter(messages)
-
     if sources_used:
-        answer += f"\n\nSources: {', '.join(sources_used)}"
+        answer += f"\n\n— Sources: {', '.join(sources_used)}"
 
     history.append((message, answer))
     return "", history
@@ -623,170 +839,381 @@ def clear_chat():
     return []
 
 
-# ---------------- Custom CSS ----------------
-custom_css = """
-@import url('https://fonts.googleapis.com/css2?family=Syne:wght@400;600;700;800&family=DM+Mono:wght@300;400;500&display=swap');
+# ═══════════════════════════════════════════════
+#  CSS  —  Warm Ink editorial luxury theme
+# ═══════════════════════════════════════════════
+CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Playfair+Display:ital,wght@0,400;0,700;0,900;1,400&family=Courier+Prime:wght@400;700&display=swap');
+
+/* ── Reset & base ── */
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
 
 :root {
-    --bg: #0d0f12;
-    --surface: #13161b;
-    --surface2: #1a1e26;
-    --border: #252a35;
-    --accent: #4fffb0;
-    --accent2: #00c2ff;
-    --text: #e8eaf0;
-    --muted: #6b7280;
+    --ink:      #0e0c08;
+    --paper:    #16130d;
+    --card:     #1c1a14;
+    --card2:    #232018;
+    --border:   #332d1e;
+    --gold:     #c9a85c;
+    --gold2:    #e8c87a;
+    --cream:    #f5e6c8;
+    --muted:    #7a6d55;
+    --red:      #c0392b;
 }
 
-body, .gradio-container {
-    background: var(--bg) !important;
-    font-family: 'DM Mono', monospace !important;
-    color: var(--text) !important;
-}
+html, body { background: var(--ink) !important; }
 
 .gradio-container {
-    max-width: 1100px !important;
+    background: var(--ink) !important;
+    max-width: 1160px !important;
     margin: 0 auto !important;
+    padding: 0 !important;
+    font-family: 'Courier Prime', monospace !important;
 }
 
-.app-header {
+/* ── Masthead ── */
+.masthead {
+    position: relative;
     text-align: center;
-    padding: 36px 0 28px;
-    border-bottom: 1px solid var(--border);
-    margin-bottom: 28px;
+    padding: 52px 24px 36px;
+    border-bottom: 2px solid var(--border);
+    overflow: hidden;
 }
-
-.app-header h1 {
-    font-family: 'Syne', sans-serif;
-    font-size: 2.4rem;
-    font-weight: 800;
-    background: linear-gradient(135deg, var(--accent), var(--accent2));
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    background-clip: text;
-    margin: 0 0 6px;
-    letter-spacing: -1px;
+.masthead::before {
+    content: '';
+    position: absolute;
+    inset: 0;
+    background: radial-gradient(ellipse 70% 60% at 50% 0%, #3a2a0a22 0%, transparent 70%);
+    pointer-events: none;
 }
-
-.app-header p {
+.masthead-kicker {
+    font-family: 'Courier Prime', monospace;
+    font-size: 0.65rem;
+    letter-spacing: 5px;
+    text-transform: uppercase;
+    color: var(--gold);
+    margin-bottom: 10px;
+}
+.masthead h1 {
+    font-family: 'Playfair Display', serif !important;
+    font-size: clamp(2.4rem, 5vw, 4rem) !important;
+    font-weight: 900 !important;
+    color: var(--cream) !important;
+    line-height: 1.05 !important;
+    letter-spacing: -1.5px !important;
+    margin-bottom: 10px !important;
+}
+.masthead h1 em {
+    font-style: italic;
+    color: var(--gold2);
+}
+.masthead-sub {
+    font-family: 'Courier Prime', monospace;
+    font-size: 0.78rem;
     color: var(--muted);
-    font-size: 0.85rem;
-    margin: 0;
-    font-family: 'DM Mono', monospace;
+    letter-spacing: 1px;
+}
+.masthead-rule {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    margin: 18px auto 0;
+    max-width: 320px;
+}
+.masthead-rule hr {
+    flex: 1;
+    border: none;
+    border-top: 1px solid var(--border);
+}
+.masthead-rule span {
+    color: var(--gold);
+    font-size: 0.65rem;
+    letter-spacing: 3px;
+    text-transform: uppercase;
+    white-space: nowrap;
+    font-family: 'Courier Prime', monospace;
 }
 
-.section-label {
-    font-family: 'Syne', sans-serif;
-    font-size: 0.7rem;
-    font-weight: 700;
-    letter-spacing: 2.5px;
+/* ── Layout columns ── */
+.layout-wrap {
+    display: grid;
+    grid-template-columns: 320px 1fr;
+    gap: 0;
+    min-height: 620px;
+}
+.left-col {
+    border-right: 1px solid var(--border);
+    padding: 28px 24px;
+    background: var(--paper);
+}
+.right-col {
+    padding: 28px 28px 20px;
+    display: flex;
+    flex-direction: column;
+    background: var(--ink);
+}
+
+/* ── Section labels ── */
+.sec-label {
+    font-family: 'Courier Prime', monospace;
+    font-size: 0.6rem;
+    letter-spacing: 4px;
     text-transform: uppercase;
-    color: var(--accent);
-    margin-bottom: 10px;
+    color: var(--gold);
+    border-bottom: 1px solid var(--border);
+    padding-bottom: 8px;
+    margin-bottom: 16px;
+}
+
+/* ── File upload zone ── */
+.upload-zone .wrap {
+    background: var(--card) !important;
+    border: 2px dashed var(--border) !important;
+    border-radius: 12px !important;
+    transition: border-color 0.25s, background 0.25s !important;
+    min-height: 120px !important;
+}
+.upload-zone .wrap:hover {
+    border-color: var(--gold) !important;
+    background: var(--card2) !important;
+}
+.upload-zone .wrap svg { color: var(--muted) !important; }
+.upload-zone .wrap p, .upload-zone label {
+    color: var(--muted) !important;
+    font-family: 'Courier Prime', monospace !important;
+    font-size: 0.8rem !important;
+}
+
+/* ── Buttons ── */
+.btn-primary {
+    background: linear-gradient(135deg, #b8923a, #e8c87a) !important;
+    color: #0e0c08 !important;
+    font-family: 'Playfair Display', serif !important;
+    font-weight: 700 !important;
+    font-size: 0.88rem !important;
+    letter-spacing: 0.5px !important;
+    border: none !important;
+    border-radius: 8px !important;
+    padding: 11px 0 !important;
+    width: 100% !important;
+    cursor: pointer !important;
+    transition: opacity 0.2s, transform 0.1s !important;
+    box-shadow: 0 4px 20px #c9a85c22 !important;
 }
+.btn-primary:hover { opacity: 0.88 !important; transform: translateY(-1px) !important; }
+.btn-primary:active { transform: translateY(0) !important; }
+
+.btn-send {
+    background: linear-gradient(135deg, #b8923a, #e8c87a) !important;
+    color: #0e0c08 !important;
+    font-family: 'Playfair Display', serif !important;
+    font-weight: 700 !important;
+    font-size: 0.85rem !important;
+    border: none !important;
+    border-radius: 8px !important;
+    padding: 10px 22px !important;
+    cursor: pointer !important;
+    transition: opacity 0.2s !important;
+    white-space: nowrap !important;
+}
+.btn-send:hover { opacity: 0.85 !important; }
 
-textarea, input[type="text"] {
-    background: var(--surface2) !important;
+.btn-clear {
+    background: transparent !important;
+    color: var(--muted) !important;
     border: 1px solid var(--border) !important;
+    font-family: 'Courier Prime', monospace !important;
+    font-size: 0.78rem !important;
     border-radius: 8px !important;
-    color: var(--text) !important;
-    font-family: 'DM Mono', monospace !important;
+    padding: 10px 16px !important;
+    cursor: pointer !important;
+    transition: border-color 0.2s, color 0.2s !important;
+    white-space: nowrap !important;
+}
+.btn-clear:hover { border-color: var(--gold) !important; color: var(--gold) !important; }
+
+/* ── Chatbot ── */
+.chatbot-wrap .wrap {
+    background: transparent !important;
+    border: none !important;
+}
+.chatbot-wrap {
+    flex: 1;
+    margin-bottom: 16px;
+}
+
+/* User bubble */
+.message-wrap .user, .message.user {
+    background: var(--card2) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: 14px 14px 4px 14px !important;
+    color: var(--cream) !important;
+    font-family: 'Courier Prime', monospace !important;
+    font-size: 0.87rem !important;
+    padding: 12px 16px !important;
+    max-width: 80% !important;
+    margin-left: auto !important;
+}
+
+/* Bot bubble */
+.message-wrap .bot, .message.bot {
+    background: var(--card) !important;
+    border: 1px solid #3a3020 !important;
+    border-left: 3px solid var(--gold) !important;
+    border-radius: 4px 14px 14px 14px !important;
+    color: var(--cream) !important;
+    font-family: 'Courier Prime', monospace !important;
     font-size: 0.87rem !important;
+    padding: 12px 16px !important;
+    max-width: 88% !important;
+    line-height: 1.6 !important;
 }
-textarea:focus, input[type="text"]:focus {
-    border-color: var(--accent) !important;
-    box-shadow: 0 0 0 2px rgba(79,255,176,0.08) !important;
+
+/* Empty state placeholder */
+.chatbot-wrap .placeholder {
+    color: var(--muted) !important;
+    font-family: 'Courier Prime', monospace !important;
+    font-size: 0.82rem !important;
 }
 
-.footer-note {
+/* ── Question input ── */
+.question-input textarea {
+    background: var(--card) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: 10px !important;
+    color: var(--cream) !important;
+    font-family: 'Courier Prime', monospace !important;
+    font-size: 0.88rem !important;
+    padding: 12px 14px !important;
+    resize: none !important;
+    transition: border-color 0.2s !important;
+    line-height: 1.5 !important;
+}
+.question-input textarea:focus {
+    border-color: var(--gold) !important;
+    outline: none !important;
+    box-shadow: 0 0 0 3px #c9a85c15 !important;
+}
+.question-input textarea::placeholder { color: var(--muted) !important; }
+.question-input label { display: none !important; }
+
+/* ── Scrollbars ── */
+::-webkit-scrollbar { width: 5px; height: 5px; }
+::-webkit-scrollbar-track { background: var(--paper); }
+::-webkit-scrollbar-thumb { background: var(--border); border-radius: 4px; }
+::-webkit-scrollbar-thumb:hover { background: var(--gold); }
+
+/* ── Footer ── */
+.site-footer {
     text-align: center;
-    margin-top: 28px;
-    color: #2d3340;
-    font-size: 0.72rem;
-    font-family: 'DM Mono', monospace;
-    letter-spacing: 0.5px;
+    padding: 16px;
+    border-top: 1px solid var(--border);
+    font-family: 'Courier Prime', monospace;
+    font-size: 0.68rem;
+    color: #3a3020;
+    letter-spacing: 1.5px;
+    text-transform: uppercase;
 }
-"""
 
+/* Gradio internals cleanup */
+.gr-padded { padding: 0 !important; }
+footer.svelte-1ax1toq { display: none !important; }
+.hide-label label { display: none !important; }
+"""
 
-# ---------------- Gradio UI ----------------
+# ═══════════════════════════════════════════════
+#  Gradio UI
+# ═══════════════════════════════════════════════
 with gr.Blocks(
     title="PDF RAG Bot",
-    css=custom_css,
+    css=CSS,
     theme=gr.themes.Base(
-        primary_hue="emerald",
-        neutral_hue="slate",
-    )
+        primary_hue="amber",
+        neutral_hue="stone",
+    ),
 ) as demo:
 
+    # ── Masthead ──
     gr.HTML("""
-    <div class="app-header">
-        <h1>⚡ PDF RAG Bot</h1>
-        <p>Upload PDFs &nbsp;·&nbsp; Semantic chunking &nbsp;·&nbsp; Ask anything &nbsp;·&nbsp; AI answers with page sources</p>
+    <div class="masthead">
+      <div class="masthead-kicker">Intelligent Document Analysis</div>
+      <h1>The <em>PDF</em> Oracle</h1>
+      <div class="masthead-sub">Upload · Index · Interrogate · Discover</div>
+      <div class="masthead-rule">
+        <hr/><span>est. 2025</span><hr/>
+      </div>
     </div>
     """)
 
-    with gr.Row(equal_height=False):
+    # ── Two-column layout ──
+    with gr.Row(equal_height=True):
 
-        # ── Left: Upload panel ──
-        with gr.Column(scale=1, min_width=280):
-            gr.HTML('<div class="section-label">📂 Document Upload</div>')
+        # LEFT — Upload panel
+        with gr.Column(scale=0, min_width=300):
+            gr.HTML('<div class="sec-label">§ I — Document Vault</div>')
 
             file_input = gr.File(
-                label="Drop PDF files here",
+                label="Drop PDFs here or click to browse",
                 file_count="multiple",
                 file_types=[".pdf"],
+                elem_classes=["upload-zone"],
+            )
+
+            upload_btn = gr.Button(
+                "⬆  Index Documents",
+                variant="primary",
+                elem_classes=["btn-primary"],
             )
-            upload_btn = gr.Button("⚡  Upload & Index", variant="primary", size="lg")
 
-            status = gr.Textbox(
-                label="Status",
-                interactive=False,
-                lines=2,
+            status_html = gr.HTML(
+                value="""<div style="font-family:'Courier Prime',monospace;color:#5a4d35;font-size:0.78rem;text-align:center;padding:10px 0;letter-spacing:1px;">Awaiting documents...</div>"""
             )
-            file_list = gr.Textbox(
-                label="Indexed Files",
-                interactive=False,
-                lines=6,
-                placeholder="No files indexed yet...",
+
+            gr.HTML('<div class="sec-label" style="margin-top:20px;">§ II — Indexed Files</div>')
+
+            file_cards_html = gr.HTML(
+                value="""<div style="font-family:'Courier Prime',monospace;color:#5a4d35;font-size:0.78rem;text-align:center;padding:16px 0;">No files indexed yet</div>"""
             )
 
-        # ── Right: Chat panel ──
-        with gr.Column(scale=2):
-            gr.HTML('<div class="section-label">💬 Chat with your PDFs</div>')
+        # RIGHT — Chat panel
+        with gr.Column(scale=1):
+            gr.HTML('<div class="sec-label">§ III — Inquiry Chamber</div>')
 
             chatbot = gr.Chatbot(
                 label="",
-                height=430,
+                height=420,
                 bubble_full_width=False,
                 show_label=False,
-                placeholder="Upload a PDF and start asking questions...",
+                elem_classes=["chatbot-wrap"],
+                placeholder="✦  Ask anything about your uploaded documents  ✦",
             )
 
-            with gr.Row():
+            with gr.Row(equal_height=True):
                 question = gr.Textbox(
                     label="",
-                    placeholder="Ask something about your documents...",
+                    placeholder="Pose your question to the oracle...",
                     lines=2,
                     scale=5,
                     show_label=False,
+                    elem_classes=["question-input"],
                 )
-                with gr.Column(scale=1, min_width=90):
-                    send_btn = gr.Button("Send ➤", variant="primary")
-                    clear_btn = gr.Button("Clear", variant="secondary")
+                with gr.Column(scale=0, min_width=120):
+                    send_btn = gr.Button("Ask ✦", variant="primary", elem_classes=["btn-send"])
+                    clear_btn = gr.Button("Clear", variant="secondary", elem_classes=["btn-clear"])
 
+    # ── Footer ──
     gr.HTML("""
-    <div class="footer-note">
-        Powered by OpenRouter &nbsp;·&nbsp; nvidia/nemotron-nano-12b &nbsp;·&nbsp;
-        sentence-transformers &nbsp;·&nbsp; FAISS vector search
+    <div class="site-footer">
+        Powered by OpenRouter &nbsp;·&nbsp; NVIDIA Nemotron &nbsp;·&nbsp;
+        Sentence-Transformers &nbsp;·&nbsp; FAISS &nbsp;·&nbsp; PyMuPDF
     </div>
     """)
 
-    # Events
+    # ── Events ──
     upload_btn.click(
         upload_and_index,
         inputs=[file_input],
-        outputs=[status, file_list],
+        outputs=[status_html, file_cards_html],
     )
     send_btn.click(
         chat,