Upload folder using huggingface_hub

README.md

@@ -1,10 +1 @@
----
-title: Docfetch
-emoji: 👀
-colorFrom: red
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Multi-document-Embedding-Search-Engine-with-Caching

eval/evaluate.py

@@ -0,0 +1,113 @@
+import json
+import requests
+import numpy as np
+
+
+API_URL = "http://localhost:8000/search"
+
+# =====================================================
+# Utility: MRR
+# =====================================================
+def compute_mrr(all_ranks):
+    if not all_ranks:
+        return 0.0
+    rr = [1.0 / r for r in all_ranks]
+    return float(np.mean(rr))
+
+
+# =====================================================
+# Utility: NDCG@K
+# =====================================================
+def compute_ndcg(results, k):
+    """results = [1,0,0...] relevance for retrieved docs"""
+    dcg = 0
+    for rank, rel in enumerate(results[:k], start=1):
+        if rel == 1:
+            dcg += 1 / np.log2(rank + 1)
+
+    idcg = 1 / np.log2(1 + 1)  # ideal rank = 1
+    return dcg / idcg if idcg != 0 else 0
+
+
+# =====================================================
+# MAIN EVALUATION FUNCTION
+# =====================================================
+def run_evaluation(query_file="generated_queries.json", top_k=10):
+    """
+    top_k is FIXED = 10 for a realistic evaluation.
+    """
+
+    with open(query_file) as f:
+        queries = json.load(f)
+
+    correct = []
+    ranks = []
+    ndcg_scores = []
+    detailed = []
+
+    for item in queries:
+        query = item["query"]
+        expected = item["doc_id"] + ".txt"
+
+        # ----------------------------
+        # CALL API
+        # ----------------------------
+        resp = requests.post(API_URL, json={"query": query, "top_k": top_k})
+        if resp.status_code != 200:
+            continue
+
+        results = resp.json().get("results", [])
+        retrieved = [r["filename"] for r in results]
+
+        # relevance array for NDCG
+        relevance = [1 if fn == expected else 0 for fn in retrieved]
+
+        # ----------------------------
+        # ACCURACY
+        # ----------------------------
+        hit = expected in retrieved
+        correct.append(1 if hit else 0)
+
+        # ----------------------------
+        # RANK for MRR
+        # ----------------------------
+        if hit:
+            rank_position = retrieved.index(expected) + 1
+            ranks.append(rank_position)
+        else:
+            rank_position = None
+
+        # ----------------------------
+        # NDCG
+        # ----------------------------
+        ndcg_scores.append(compute_ndcg(relevance, top_k))
+
+        # ----------------------------
+        # Save detail
+        # ----------------------------
+        detailed.append({
+            "query": query,
+            "expected": expected,
+            "retrieved": retrieved,
+            "rank": rank_position,
+            "is_correct": hit
+        })
+
+    # =====================================================
+    # FINAL METRICS
+    # =====================================================
+    accuracy = round(np.mean(correct) * 100, 2)
+    mrr = round(compute_mrr(ranks), 4)
+    mean_ndcg = round(float(np.mean(ndcg_scores)), 4)
+
+    summary = {
+        "accuracy": accuracy,
+        "mrr": mrr,
+        "ndcg": mean_ndcg,
+        "total_queries": len(queries),
+        "correct_count": sum(correct),
+        "incorrect_count": len(queries) - sum(correct),
+        "details": detailed
+    }
+
+    return summary

requirements.txt

@@ -0,0 +1,15 @@
+fastapi
+uvicorn[standard]
+google-genai
+sentence-transformers
+faiss-cpu
+numpy
+scikit-learn
+
+requests
+pydantic
+
+streamlit
+
+# Only really needed in Colab for exposing Streamlit, safe to keep
+pyngrok

src/api_gateway/app.py

@@ -0,0 +1,85 @@
+# src/api_gateway/app.py
+from fastapi import FastAPI
+from pydantic import BaseModel
+import requests
+import time
+app = FastAPI(title="API Gateway")
+
+DOC_URL = "http://localhost:9001"
+EMBED_URL = "http://localhost:9002"
+SEARCH_URL = "http://localhost:9003"
+EXPLAIN_URL = "http://localhost:9004"
+DATA_FOLDER = "data/docs"
+
+class SearchQuery(BaseModel):
+    query: str
+    top_k: int = 5
+
+@app.post("/initialize")
+def initialize():
+    # 1) load docs
+    d = requests.post(f"{DOC_URL}/load_docs", json={"folder": DATA_FOLDER}, timeout=20)
+    if d.status_code != 200:
+        return {"error": "doc_load_failed", "detail": d.text}
+    docs = d.json().get("documents", [])
+
+    # 2) prepare docs for embed_batch: ensure keys filename,text,hash
+    batch_docs = [{"filename": x["filename"], "text": x.get("clean_text", x.get("text","")), "hash": x["hash"]} for x in docs]
+
+    # 3) embed batch
+    e = requests.post(f"{EMBED_URL}/embed_batch", json={"docs": batch_docs}, timeout=60)
+    if e.status_code != 200:
+        return {"error": "embed_failed", "detail": e.text}
+    embed_out = e.json()
+    embeddings = [r["embedding"] for r in embed_out["results"]]
+    meta = {i: r["filename"] for i, r in enumerate(embed_out["results"])}
+
+    # 4) build index
+    b = requests.post(f"{SEARCH_URL}/build_index", json={"embeddings": embeddings, "meta": meta}, timeout=60)
+    if b.status_code != 200:
+        return {"error": "build_index_failed", "detail": b.text}
+
+    return {"docs_loaded": len(docs), "embeddings": len(embeddings), "build": b.json()}
+
+@app.post("/search")
+def search(req: SearchQuery):
+    # embed query
+    unique_id = str(time.time())
+    q = requests.post(f"{EMBED_URL}/embed_document", json={"filename": f"query_{unique_id}", "text": req.query, "hash": unique_id},   timeout=10)
+    if q.status_code != 200:
+        return {"error": "embed_query_failed", "detail": q.text}
+    q_emb = q.json()["embedding"]
+
+    # search vectors
+    s = requests.post(f"{SEARCH_URL}/search_vectors", json={"query_embedding": q_emb, "top_k": req.top_k}, timeout=10)
+    if s.status_code != 200:
+        return {"error": "search_failed", "detail": s.text}
+    sdata = s.json()
+    if "error" in sdata:
+        return {"error": "search_index_error", "detail": sdata}
+
+    scores = sdata["scores"]
+    ids = sdata["ids"]
+    meta = sdata["meta"]  # { "0": filename, ... }
+
+    # for each id load doc from doc service and call explain
+    results = []
+    for score, idx in zip(scores, ids):
+        filename = meta.get(str(idx))
+        if filename is None:
+            continue
+        doc_resp = requests.get(f"{DOC_URL}/get_doc/{filename}", timeout=10)
+        if doc_resp.status_code != 200:
+            continue
+        doc = doc_resp.json()  # has clean_text, original_text, ...
+        # explain
+        exp = requests.post(f"{EXPLAIN_URL}/explain", json={"query": req.query, "document_text": doc.get("clean_text","")}, timeout=10)
+        explanation = exp.json() if exp.status_code == 200 else {}
+        results.append({
+            "filename": filename,
+            "score": float(score),
+            "preview": doc.get("clean_text","")[:350],
+            "full_text": doc.get("original_text",""),
+            "explanation": explanation
+        })
+    return {"results": results}

src/doc_service/app.py

@@ -0,0 +1,38 @@
+# src/doc_service/app.py
+from fastapi import FastAPI
+from pydantic import BaseModel
+from .utils import preprocess_documents, load_original_text
+
+app = FastAPI(title="Document Service")
+
+class FolderRequest(BaseModel):
+    folder: str
+
+# In-memory stores (simple)
+_DOCUMENTS = {}  # filename -> dict with clean_text, hash, length, original_text
+
+@app.post("/load_docs")
+def load_docs(req: FolderRequest):
+    try:
+        docs = preprocess_documents(req.folder)
+        for d in docs:
+            _DOCUMENTS[d["filename"]] = {
+                "filename": d["filename"],
+                "clean_text": d["clean_text"],
+                "hash": d["hash"],
+                "length": d["length"],
+                "original_text": d["original_text"]
+            }
+        return {"count": len(docs), "documents": list(_DOCUMENTS.values())}
+    except Exception as e:
+        return {"error": str(e)}
+
+@app.get("/get_doc/{filename}")
+def get_doc(filename: str):
+    if filename not in _DOCUMENTS:
+        return {"error": "not_found", "message": f"{filename} not found"}
+    return _DOCUMENTS[filename]
+
+@app.get("/all_docs")
+def all_docs():
+    return {"count": len(_DOCUMENTS), "documents": list(_DOCUMENTS.values())}

src/doc_service/utils.py

@@ -0,0 +1,53 @@
+# src/doc_service/utils.py
+import os
+import hashlib
+import re
+
+def load_text_files(folder_path: str):
+    docs = []
+    for fname in sorted(os.listdir(folder_path)):
+        if fname.endswith(".txt"):
+            full_path = os.path.join(folder_path, fname)
+            with open(full_path, "r", encoding="utf-8", errors="ignore") as f:
+                text = f.read()
+            docs.append({
+                "filename": fname,
+                "path": full_path,
+                "text": text
+            })
+    return docs
+
+
+def load_original_text(folder_path: str, filename: str):
+    path = os.path.join(folder_path, filename)
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        return f.read()
+
+
+def clean_text(text: str) -> str:
+    text = text.lower()
+    text = re.sub(r'<.*?>', '', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+
+def compute_hash(text: str) -> str:
+    return hashlib.md5(text.encode("utf-8")).hexdigest()
+
+
+def preprocess_documents(folder_path: str):
+    raw_docs = load_text_files(folder_path)
+    result = []
+
+    for doc in raw_docs:
+        cleaned = clean_text(doc["text"])
+        h = compute_hash(cleaned)
+        result.append({
+            "filename": doc["filename"],
+            "clean_text": cleaned,
+            "hash": h,
+            "length": len(cleaned.split()),
+            "original_text": doc["text"]
+        })
+
+    return result

src/embed_service/app.py

@@ -0,0 +1,63 @@
+# src/embed_service/app.py
+from fastapi import FastAPI
+from pydantic import BaseModel
+from .embedder import Embedder
+from .cache_manager import CacheManager
+import numpy as np
+
+app = FastAPI(title="Embed Service")
+
+embedder = Embedder()
+cache = CacheManager()
+
+class EmbedRequest(BaseModel):
+    filename: str
+    text: str
+    hash: str
+
+@app.post("/embed_document")
+def embed_document(req: EmbedRequest):
+    if cache.exists(req.filename, req.hash):
+        emb = cache.get_embedding(req.filename)
+        return {"filename": req.filename, "cached": True, "embedding": emb.tolist()}
+    emb = embedder.embed_text(req.text)
+    cache.add_embedding(req.filename, req.hash, emb)
+    return {"filename": req.filename, "cached": False, "embedding": emb.tolist()}
+
+class BatchEmbedRequest(BaseModel):
+    docs: list
+
+@app.post("/embed_batch")
+def embed_batch(req: BatchEmbedRequest):
+    results = []
+    new_texts, new_files, new_hashes = [], [], []
+    for d in req.docs:
+        filename = d.get("filename")
+        file_hash = d.get("hash")
+        text = d.get("text") or d.get("clean_text") or ""
+        if cache.exists(filename, file_hash):
+            results.append({"filename": filename, "cached": True, "embedding": cache.get_embedding(filename).tolist()})
+        else:
+            new_files.append(filename)
+            new_hashes.append(file_hash)
+            new_texts.append(text)
+
+    if new_texts:
+        new_embs = embedder.embed_batch(new_texts)
+        for fname, h, emb in zip(new_files, new_hashes, new_embs):
+            cache.add_embedding(fname, h, emb)
+            results.append({"filename": fname, "cached": False, "embedding": emb.tolist()})
+
+    return {"count": len(results), "results": results}
+
+@app.get("/all_embeddings")
+def get_all_embeddings():
+    meta, embs = cache.all_embeddings()
+    return {"meta": meta, "embeddings": embs.tolist()}
+
+# convenience endpoint called earlier by older code
+@app.post("/embed_all")
+def embed_all_docs(docs: list):
+    # docs: list of {filename, clean_text, hash}
+    batch = {"docs": [{"filename": d["filename"], "text": d.get("clean_text") or d.get("text", ""), "hash": d["hash"]} for d in docs]}
+    return embed_batch(BatchEmbedRequest(**batch))

src/embed_service/cache_manager.py

@@ -0,0 +1,48 @@
+# src/embed_service/cache_manager.py
+import os
+import json
+import numpy as np
+
+CACHE_DIR = "cache"
+META_PATH = f"{CACHE_DIR}/embed_meta.json"
+EMB_PATH = f"{CACHE_DIR}/embeddings.npy"
+
+class CacheManager:
+    def __init__(self):
+        os.makedirs(CACHE_DIR, exist_ok=True)
+        if os.path.exists(META_PATH):
+            with open(META_PATH, "r") as f:
+                self.meta = json.load(f)
+        else:
+            self.meta = {}  # filename -> {"hash":..., "index": int}
+
+        if os.path.exists(EMB_PATH):
+            self.embeddings = np.load(EMB_PATH)
+        else:
+            # empty array shaped (0, dim) — we'll resize when first embedding arrives
+            self.embeddings = np.zeros((0, 384), dtype="float32")
+
+    def save(self):
+        with open(META_PATH, "w") as f:
+            json.dump(self.meta, f, indent=2)
+        np.save(EMB_PATH, self.embeddings)
+
+    def exists(self, filename: str, file_hash: str) -> bool:
+        return filename in self.meta and self.meta[filename]["hash"] == file_hash
+
+    def get_embedding(self, filename: str):
+        idx = int(self.meta[filename]["index"])
+        return self.embeddings[idx]
+
+    def add_embedding(self, filename: str, file_hash: str, embedding):
+        embedding = embedding.astype("float32")
+        idx = len(self.embeddings)
+        self.meta[filename] = {"hash": file_hash, "index": idx}
+        if self.embeddings.shape[0] == 0:
+            self.embeddings = embedding.reshape(1, -1)
+        else:
+            self.embeddings = np.vstack([self.embeddings, embedding.reshape(1, -1)])
+        self.save()
+
+    def all_embeddings(self):
+        return self.meta, self.embeddings

src/embed_service/embedder.py

@@ -0,0 +1,19 @@
+# src/embed_service/embedder.py
+from sentence_transformers import SentenceTransformer
+import numpy as np
+
+class Embedder:
+    def __init__(self, model_name="all-MiniLM-L6-v2"):
+        print(f"Loading embedding model: {model_name}")
+        self.model = SentenceTransformer(model_name)
+
+    def embed_text(self, text: str):
+        emb = self.model.encode(text, convert_to_numpy=True)
+        return emb.astype("float32")
+
+    def embed_batch(self, texts: list):
+        embs = self.model.encode(texts, convert_to_numpy=True)
+        return embs.astype("float32")
+
+    def dim(self):
+        return self.model.get_sentence_embedding_dimension()

src/explain_service/app.py

@@ -0,0 +1,15 @@
+# src/explain_service/app.py
+from fastapi import FastAPI
+from pydantic import BaseModel
+from .explainer import Explainer
+
+app = FastAPI(title="Explain Service")
+explainer = Explainer()
+
+class ExplainRequest(BaseModel):
+    query: str
+    document_text: str
+
+@app.post("/explain")
+def explain_doc(req: ExplainRequest):
+    return explainer.explain(req.query, req.document_text)

src/explain_service/explainer.py

@@ -0,0 +1,114 @@
+# src/explain_service/explainer.py
+
+import re
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from google import genai
+
+STOPWORDS = set("""
+a an the and or but if while with without for on in into by to from of is are was were be been being as it this that these those
+""".split())
+
+
+class Explainer:
+    def __init__(self):
+        self.model = SentenceTransformer("all-MiniLM-L6-v2")
+        # LLM Client
+        self.client = genai.Client(api_key="AIzaSyBXEkZ7DF_QxuKwyxsXQ6FZ_qLk4k7W1n0")
+
+    # ---------------------------
+    # TOKENIZER
+    # ---------------------------
+    def tokenize(self, text: str):
+        text = text.lower()
+        tokens = re.findall(r"[a-zA-Z]+", text)
+        tokens = [t for t in tokens if t not in STOPWORDS]
+        return tokens
+
+    # ---------------------------
+    # KEYWORD OVERLAP
+    # ---------------------------
+    def keyword_overlap(self, query: str, doc: str):
+        q_tokens = set(self.tokenize(query))
+        d_tokens = set(self.tokenize(doc))
+
+        overlap = q_tokens.intersection(d_tokens)
+        overlap_ratio = len(overlap) / (len(q_tokens) + 1e-8)
+
+        return list(overlap), float(overlap_ratio)
+
+    # ---------------------------
+    # BEST SENTENCES MATCHING QUERY
+    # ---------------------------
+    def best_sentences(self, query: str, doc: str, top_k=2):
+        sentences = re.split(r"[.!?]", doc)
+        sentences = [s.strip() for s in sentences if len(s.strip()) > 0]
+
+        if len(sentences) == 0:
+            return []
+
+        q_emb = self.model.encode(query, convert_to_numpy=True)
+        s_embs = self.model.encode(sentences, convert_to_numpy=True)
+
+        q_emb = q_emb / (np.linalg.norm(q_emb) + 1e-10)
+        s_norm = s_embs / (np.linalg.norm(s_embs, axis=1, keepdims=True) + 1e-10)
+
+        sims = (s_norm @ q_emb).tolist()
+        top_ids = np.argsort(sims)[::-1][:top_k]
+
+        results = []
+        for idx in top_ids:
+            results.append({
+                "sentence": sentences[idx],
+                "score": float(sims[idx])
+            })
+
+        return results
+
+    # ---------------------------
+    # LLM-LEVEL EXPLANATION
+    # ---------------------------
+    def llm_explain(self, query, doc_text, top_sentences):
+
+        formatted_sentences = "\n".join(
+            [f"- {s['sentence']} (score: {s['score']:.2f})" for s in top_sentences]
+        )
+
+        prompt = f"""
+You are an AI assistant that explains WHY a document matches a user query.
+
+QUERY:
+{query}
+
+DOCUMENT EXCERPT:
+{doc_text[:500]}
+
+MOST RELEVANT SENTENCES:
+{formatted_sentences}
+
+Write 2–3 natural sentences explaining WHY this document is relevant.
+"""
+
+        response = self.client.models.generate_content(
+            model="gemini-2.5-flash",
+            contents=prompt,
+            config={"temperature": 0.4}
+        )
+
+        return response.text.strip()
+
+    # ---------------------------
+    # MAIN EXPLAIN FUNCTION
+    # ---------------------------
+    def explain(self, query: str, doc_text: str):
+
+        keywords, overlap_ratio = self.keyword_overlap(query, doc_text)
+        top_sents = self.best_sentences(query, doc_text)
+        llm_summary = self.llm_explain(query, doc_text, top_sents)
+
+        return {
+            "keyword_overlap": keywords,
+            "overlap_ratio": overlap_ratio,
+            "top_sentences": top_sents,
+            "llm_explanation": llm_summary
+        }

src/search_service/app.py

@@ -0,0 +1,33 @@
+# src/search_service/app.py
+from fastapi import FastAPI
+from pydantic import BaseModel
+from .indexer import FAISSIndexer
+import numpy as np
+
+app = FastAPI(title="Search Service")
+
+indexer = FAISSIndexer()
+# attempt load if exists
+indexer.try_load()
+
+class BuildIndexRequest(BaseModel):
+    embeddings: list
+    meta: dict
+
+@app.post("/build_index")
+def build_index(req: BuildIndexRequest):
+    embeddings = np.array(req.embeddings, dtype="float32")
+    indexer.build(embeddings, req.meta)
+    return {"status": "index_built", "count": embeddings.shape[0]}
+
+class SearchRequest(BaseModel):
+    query_embedding: list
+    top_k: int = 5
+
+@app.post("/search_vectors")
+def search_vectors(req: SearchRequest):
+    if indexer.index is None:
+        return {"error": "index_not_built"}
+    query = np.array(req.query_embedding, dtype="float32")
+    scores, ids = indexer.search(query, req.top_k)
+    return {"scores": scores, "ids": ids, "meta": indexer.meta}

src/search_service/indexer.py

@@ -0,0 +1,48 @@
+# src/search_service/indexer.py
+import numpy as np
+import faiss
+import os
+import pickle
+
+class FAISSIndexer:
+    def __init__(self):
+        self.index = None
+        self.meta = None
+        self.index_path = "faiss_index.bin"
+        self.meta_path = "faiss_meta.pkl"
+
+    def try_load(self):
+        if not os.path.exists(self.meta_path) or not os.path.exists(self.index_path):
+            return None, None
+        with open(self.meta_path, "rb") as f:
+            meta = pickle.load(f)
+        index = faiss.read_index(self.index_path)
+        self.index = index
+        self.meta = meta
+        return meta, None
+
+    def build(self, embeddings, meta):
+        # embeddings: numpy array (N, dim)
+        norms = np.linalg.norm(embeddings, axis=1, keepdims=True) + 1e-10
+        embeddings = embeddings / norms
+        dim = embeddings.shape[1]
+        index = faiss.IndexFlatL2(dim)
+        index.add(embeddings)
+        faiss.write_index(index, self.index_path)
+        # normalize meta keys to str(index)->filename
+        meta_map = {}
+        for k, v in meta.items():
+            meta_map[str(k)] = v
+        with open(self.meta_path, "wb") as f:
+            pickle.dump(meta_map, f)
+        self.index = index
+        self.meta = meta_map
+
+    def search(self, query_emb, top_k):
+        if self.index is None:
+            raise ValueError("FAISS index is not loaded!")
+        q = query_emb / (np.linalg.norm(query_emb) + 1e-10)
+        q = q.reshape(1, -1)
+        distances, ids = self.index.search(q, top_k)
+        # distances shape (1, k), ids shape (1, k)
+        return distances[0].tolist(), ids[0].tolist()

src/ui/streamlit_app.py

@@ -0,0 +1,407 @@
+import streamlit as st
+import requests
+import json
+import html
+import sys
+import os
+import importlib
+
+# ------------------------------------------
+# Add project root + eval folder to path
+# ------------------------------------------
+CURRENT_DIR = os.path.dirname(__file__)
+SRC_DIR = os.path.dirname(CURRENT_DIR)
+PROJECT_ROOT = os.path.dirname(SRC_DIR)
+
+sys.path.append(PROJECT_ROOT)
+sys.path.append(os.path.join(PROJECT_ROOT, "eval"))
+
+# ------------------------------------------
+# FORCE RELOAD evaluate module
+# ------------------------------------------
+import eval.evaluate as eval_module
+importlib.reload(eval_module)
+from eval.evaluate import run_evaluation
+
+
+API_GATEWAY_URL = "http://localhost:8000"
+
+st.set_page_config(
+    page_title="Gemini Search",
+    page_icon="✨",
+    layout="wide",
+    initial_sidebar_state="expanded", # Changed from "collapsed" to "expanded"
+)
+
+# =======================
+# GEMINI UI STYLING
+# =======================
+st.markdown("""
+<style>
+    /* Global Font & Background */
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+    
+    html, body, [class*="css"] {
+        font-family: 'Inter', sans-serif;
+        background-color: #ffffff; /* White Background */
+        color: #1f1f1f; /* Dark text for contrast */
+    }
+
+    /* --- INPUT FIELD FIX --- */
+    /* 1. Remove the default Streamlit border/background on the container */
+    .stTextInput > div[data-baseweb="input"] {
+        background-color: transparent !important;
+        border: none !important;
+        border-radius: 24px !important; 
+        box-shadow: none !important; 
+    }
+    
+    /* 2. Style the actual input element */
+    .stTextInput input {
+        border-radius: 24px !important;
+        background-color: #f0f4f9 !important; /* Light ash input */
+        border: 1px solid transparent !important;
+        color: #1f1f1f !important;
+        padding: 12px 20px !important;
+        font-size: 16px !important;
+        transition: all 0.2s ease;
+    }
+    
+    /* 3. Focus state - clean blue border, no default red overlay */
+    .stTextInput input:focus {
+        background-color: #ffffff !important;
+        border-color: #0b57d0 !important; /* Gemini Blue */
+        box-shadow: 0 0 0 2px rgba(11, 87, 208, 0.2) !important;
+        outline: none !important;
+    }
+
+    /* Button Styling */
+    .stButton > button {
+        border-radius: 20px;
+        font-weight: 500;
+        border: none;
+        padding: 0.5rem 1.5rem;
+        transition: all 0.3s ease;
+        white-space: nowrap; /* Forces text to stay on one line */
+        min-width: 140px;   /* Ensures button is never too skinny */
+    }
+    
+    /* Primary Search Button */
+    button[kind="primary"] {
+        background: linear-gradient(90deg, #4b90ff, #ff5546);
+        color: white;
+    }
+    button[kind="primary"]:hover {
+        opacity: 0.9;
+        box-shadow: 0 4px 12px rgba(75, 144, 255, 0.3);
+    }
+
+    /* Result Card - Light Ash Background */
+    .result-card {
+        background-color: #f0f4f9; /* Light Ash */
+        border-radius: 16px;
+        padding: 1.5rem;
+        margin-bottom: 1rem;
+        border: none; /* Removed border for cleaner look on light mode */
+        transition: transform 0.2s;
+    }
+    .result-card:hover {
+        box-shadow: 0 4px 12px rgba(0,0,0,0.05);
+    }
+
+    /* Typography in Cards */
+    .card-title {
+        color: #1f1f1f; /* Dark Title */
+        font-size: 1.1rem;
+        font-weight: 600;
+        margin-bottom: 0.5rem;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+    }
+    
+    .card-preview {
+        color: #444746; /* Darker gray for readable preview */
+        font-size: 0.95rem;
+        line-height: 1.5;
+        margin-bottom: 1rem;
+    }
+
+    /* Pills & Badges */
+    .score-badge {
+        background-color: #c4eed0; /* Light Green bg */
+        color: #0f5223; /* Dark Green text */
+        padding: 4px 12px;
+        border-radius: 12px;
+        font-size: 0.75rem;
+        font-weight: 500;
+        display: inline-block;
+    }
+    
+    .keyword-pill {
+        background-color: #c2e7ff; /* Light Blue bg */
+        color: #004a77; /* Dark Blue text */
+        padding: 2px 10px;
+        border-radius: 8px;
+        font-size: 0.8rem;
+        margin-right: 6px;
+        display: inline-block;
+        margin-bottom: 4px;
+    }
+
+    /* Gradient Text for Header */
+    .gradient-text {
+        background: linear-gradient(to right, #4285f4, #9b72cb, #d96570);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        font-weight: 700;
+        font-size: 3rem;
+    }
+    
+    /* Custom Info Box */
+    .stAlert {
+        background-color: #f0f4f9;
+        color: #1f1f1f;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# =======================
+# SIDEBAR (Settings)
+# =======================
+with st.sidebar:
+    st.markdown("### ⚙️ Settings")
+    top_k = st.slider("Top-K Results", 1, 10, 5)
+    url_input = st.text_input("API Endpoint", API_GATEWAY_URL)
+    st.divider()
+    st.subheader(" Evaluation")
+    run_eval = st.button("Run Evaluation Script")
+    st.divider()
+    st.caption(" Powered by Sentence-Transformers")
+
+API_GATEWAY_URL = url_input
+
+# =======================
+# MAIN HEADER (Gemini Style)
+# =======================
+col1, col2, col3 = st.columns([1, 6, 1])
+with col2:
+    # Use HTML for the gradient text title
+    st.markdown('<div style="text-align: center; margin-bottom: 10px;"><span class="gradient-text">Hello, Explorer</span></div>', unsafe_allow_html=True)
+    st.markdown('<div style="text-align: center; color: #444746; font-size: 1.2rem; margin-bottom: 30px;">How can I help you find documents today?</div>', unsafe_allow_html=True)
+
+
+# =======================
+# SEARCH BAR CENTERED
+# =======================
+# Centering the search bar using columns
+sc1, sc2, sc3 = st.columns([1, 4, 1])
+
+with sc2:
+    query = st.text_input(
+        "Search Query", # Label hidden by CSS/Config if needed, or set visibility hidden
+        placeholder="Ask a question about your documents...",
+        label_visibility="collapsed"
+    )
+    
+    # Buttons row
+    b1, b2, b3 = st.columns([2, 1, 2])
+    with b2:
+        submit_btn = st.button("Sparkle Search", type="primary", use_container_width=True)
+
+# =======================
+# SEARCH HANDLER
+# =======================
+if submit_btn and query.strip():
+
+    # Gemini-style spinner
+    with st.spinner("✨ Analyzing semantics..."):
+
+        response = requests.post(
+            f"{API_GATEWAY_URL}/search",
+            json={"query": query, "top_k": top_k}
+        )
+
+        if response.status_code != 200:
+            st.error(f"❌ Connection Error: {response.text}")
+            st.stop()
+
+        try:
+            data = response.json()
+        except:
+            st.error("❌ Invalid JSON response.")
+            st.stop()
+
+    if "results" not in data:
+        st.info("No relevant documents found for that query.")
+        st.stop()
+
+    # Results Header
+    st.markdown("### ✨ Search Results")
+    st.markdown("---")
+
+    # =======================
+    # DISPLAY RESULTS (Card Style)
+    # =======================
+    for item in data["results"]:
+        filename = item["filename"]
+        score = item["score"]
+        explanation = item["explanation"]
+        preview = item["preview"]
+        full_text = item["full_text"]
+
+        safe_preview = html.escape(preview)
+        
+        # Prepare keyword HTML
+        keywords = explanation.get("keyword_overlap", [])
+        keyword_html = ""
+        if keywords:
+            keyword_html = "".join([f"<span class='keyword-pill'>{kw}</span>" for kw in keywords])
+        
+        # Doc Icon (SVG) - Changed stroke to dark blue for visibility on light bg
+        doc_icon = """<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="#0b57d0" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"></path><polyline points="14 2 14 8 20 8"></polyline></svg>"""
+
+        # Main Card Render
+        st.markdown(f"""
+        <div class="result-card">
+            <div style="display:flex; justify-content:space-between; align-items:start;">
+                <div class="card-title">
+                    {doc_icon} {filename}
+                </div>
+                <div class="score-badge">match: {score:.4f}</div>
+            </div>
+            <p class="card-preview">{safe_preview}...</p>
+            <div style="margin-top: 10px;">
+                <div style="font-weight:600; color:#1f1f1f; margin-bottom:6px;">
+                   Keyword Overlap:
+                </div>
+                {keyword_html}
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+
+        # Details Expander (Standard Streamlit but styled via global CSS)
+        with st.expander(f"View Details & Full Text for {filename}"):
+            
+            overlap_ratio = explanation.get("overlap_ratio", 0)
+            sentences = explanation.get("top_sentences", [])
+            
+            st.caption(f"Semantic Overlap Ratio: {overlap_ratio:.3f}")
+            
+            if sentences:
+                st.markdown("**Key Excerpts:**")
+                for s in sentences:
+                    # Updated quote box for light mode
+                    st.markdown(f"""
+                    <div style="background: #ffffff; border-left: 3px solid #4285f4; padding: 10px; margin-bottom: 5px; border-radius: 0 8px 8px 0; box-shadow: 0 1px 3px rgba(0,0,0,0.05);">
+                        <span style="color: #1f1f1f;">"{s['sentence']}"</span> 
+                        <span style="color: #5e5e5e; font-size: 0.8em; margin-left: 10px;">(conf: {s['score']:.2f})</span>
+                    </div>
+                    """, unsafe_allow_html=True)
+            llm_expl = explanation.get("llm_explanation")
+            if llm_expl:
+                 st.markdown("**Why this document?**")
+                 st.write(llm_expl)
+            st.markdown("---")
+            st.markdown("**📄 Full Document Content:**")
+            st.code(full_text, language="text") # Using code block for better readability of raw text
+if run_eval:
+
+    st.info("Running evaluation... this may take 10–20 seconds...")
+
+    results = run_evaluation(top_k=10)
+
+    st.success("Evaluation Complete!")
+
+    # -----------------------------
+    # Summary Metrics (Horizontal)
+    # -----------------------------
+    st.markdown("##  Evaluation Summary")
+
+    c1, c2, c3, c4 = st.columns(4)
+    with c1:
+        st.metric("Accuracy", f"{results['accuracy']}%")
+    with c2:
+        st.metric("MRR", results["mrr"])
+    with c3:
+        st.metric("NDCG", results["ndcg"])
+    with c4:
+        st.metric("Queries", results["total_queries"])
+
+    st.markdown(
+        f"**Correct:** {results['correct_count']} &nbsp;&nbsp;|&nbsp;&nbsp; "
+        f"**Incorrect:** {results['incorrect_count']}"
+    )
+
+    st.markdown("---")
+
+    # -----------------------------
+    # Incorrect Results
+    # -----------------------------
+    st.markdown("##  Incorrect Fetches ")
+
+    wrong = [d for d in results["details"] if not d["is_correct"]]
+
+    if wrong:
+        for item in wrong:
+            st.markdown(f"""
+            <div style="
+                padding:14px;
+                background:#ffe5e5;
+                border-left:5px solid #ff4d4f;
+                border-radius:8px;
+                margin-bottom:10px;">
+                <b> Query:</b> {item['query']}<br>
+                <b>Expected:</b> {item['expected']}<br>
+                <b>Retrieved:</b> {item['retrieved']}<br>
+                <b>Rank:</b> {item['rank']}
+            </div>
+            """, unsafe_allow_html=True)
+    else:
+        st.success(" No incorrect queries!")
+
+    st.markdown("---")
+
+    # -----------------------------
+    # Correct Results
+    # -----------------------------
+    st.markdown("##  Correct Fetches")
+
+    correct_items = [d for d in results["details"] if d["is_correct"]]
+
+    if correct_items:
+        for item in correct_items:
+            st.markdown(f"""
+            <div style="
+                padding:14px;
+                background:#e8ffe5;
+                border-left:5px solid #2ecc71;
+                border-radius:8px;
+                margin-bottom:10px;">
+                <b> Query:</b> {item['query']}<br>
+                <b>Expected:</b> {item['expected']}<br>
+                <b>Top-K Retrieved:</b> {item['retrieved']}<br>
+                <b>Rank:</b> {item['rank']}
+            </div>
+            """, unsafe_allow_html=True)
+    else:
+        st.info("No correct queries.")
+
+    st.markdown("---")
+
+    # -----------------------------
+    # Full Table
+    # -----------------------------
+    st.markdown("##  Full Evaluation Table")
+
+    table_data = []
+    for item in results["details"]:
+        table_data.append({
+            "Query": item["query"],
+            "Expected Doc": item["expected"],
+            "Retrieved (Top-10)": ", ".join(item["retrieved"]),
+            "Correct?": "Yes" if item["is_correct"] else "No",
+            "Rank": item["rank"]
+        })
+
+    st.dataframe(table_data, use_container_width=True)