Initial Commit

.env

@@ -0,0 +1,16 @@
+# Directories (already created in Dockerfile)
+INDEX_DIR=/workspace/data/index
+CACHE_DIR=/workspace/cache
+
+# Face identification thresholds
+THRESHOLD=0.50
+MARGIN=0.05
+TOPK_DB=20
+TOPK_SHOW=3
+
+# InsightFace providers (comma separated). Default in run.sh is CPU-only.
+# For GPU container: CUDAExecutionProvider,CPUExecutionProvider
+PROVIDERS=["CPUExecutionProvider"]
+
+# Demo SQL path (sqlite); ":memory:" is also fine
+SQLITE_PATH=/workspace/data/demo.db

Dockerfile

@@ -0,0 +1,77 @@
+# --------------------------
+# Hugging Face Space (Docker) - Backend (CPU)
+# --------------------------
+FROM python:3.12-slim
+
+# =============== System deps ===============
+# - build-essential et al. for any wheels that need compile
+# - ffmpeg for audio resample
+# - libsndfile1 for python-soundfile
+# - OpenCV runtime libs already included below
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential gcc g++ make cmake pkg-config \
+    libgl1 libglib2.0-0 libsm6 libxext6 libxrender1 libgomp1 \
+    libsndfile1 ffmpeg git curl ca-certificates \
+ && rm -rf /var/lib/apt/lists/*
+
+# =============== Workspace ===============
+ENV APP_HOME=/workspace
+RUN mkdir -p $APP_HOME/app $APP_HOME/data $APP_HOME/cache && chmod -R 777 $APP_HOME
+WORKDIR $APP_HOME
+
+# Optional caches for various libs
+ENV CC=gcc CXX=g++
+ENV INSIGHTFACE_HOME=/workspace/cache/insightface
+ENV MPLCONFIGDIR=/workspace/cache/matplotlib
+
+# =============== Python deps ===============
+COPY requirements.txt ./requirements.txt
+
+# Pre-install numpy variant compatible with py3.12, then the rest
+RUN python -m pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir "numpy<2.0; python_version<'3.12'" "numpy>=2.0; python_version>='3.12'" && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Add audio utils used by /stt and /tts (already referenced in code you’ll add)
+RUN pip install --no-cache-dir soundfile faster-whisper==1.0.0
+
+# =============== Piper (offline TTS) ===============
+# Download a small/medium English voice (change to hi-IN or en-IN if you prefer)
+# Piper releases: https://github.com/rhasspy/piper/releases
+RUN curl -L -o /usr/local/bin/piper \
+      https://github.com/rhasspy/piper/releases/download/v1.2.0/piper_linux_x86_64 && \
+    chmod +x /usr/local/bin/piper
+
+# Voice (~50–80MB each). Swap to another voice if you need Indian English/Hindi.
+# See https://github.com/rhasspy/piper#voices for alternatives.
+RUN mkdir -p /models/piper/en_US && \
+    curl -L -o /models/piper/en_US/libri_tts_en_US-medium.onnx \
+      https://github.com/rhasspy/piper/releases/download/v1.2.0/libri_tts_en_US-medium.onnx
+
+# =============== faster-whisper model (offline STT) ===============
+# Pre-download the "small" model (~460 MB) so no runtime fetch is needed.
+RUN mkdir -p /models/faster-whisper
+RUN python - <<'PY'
+from faster_whisper import WhisperModel
+WhisperModel("small", download_root="/models/faster-whisper")
+print("Downloaded faster-whisper 'small' to /models/faster-whisper")
+PY
+
+# =============== App ===============
+COPY app ./app
+COPY run.sh ./run.sh
+RUN chmod +x ./run.sh
+
+# =============== Runtime ENV ===============
+# Voice/STT providers default to OFFLINE so Space does not need internet
+ENV STT_PROVIDER=offline \
+    TTS_PROVIDER=offline \
+    FW_MODEL_DIR=/models/faster-whisper \
+    FW_MODEL_SIZE=small \
+    PIPER_BIN=/usr/local/bin/piper \
+    PIPER_VOICE=/models/piper/en_US/libri_tts_en_US-medium.onnx \
+    PIPER_SAMPLE_RATE=22050 \
+    PORT=7860
+
+# Keep your existing port/cmd
+CMD ["./run.sh"]

Dockerfile copy

@@ -0,0 +1,37 @@
+# --------------------------
+# Hugging Face Space (Docker)
+# CPU-friendly default base
+# --------------------------
+FROM python:3.12-slim
+
+# System deps (add build-essential + common runtime libs for OpenCV/ONNX)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential gcc g++ make cmake pkg-config \
+    libgl1 libglib2.0-0 libsm6 libxext6 libxrender1 libgomp1 git curl && \
+    rm -rf /var/lib/apt/lists/*
+
+# Workspace & writable directories
+ENV APP_HOME=/workspace
+RUN mkdir -p $APP_HOME/app $APP_HOME/data $APP_HOME/cache && chmod -R 777 $APP_HOME
+WORKDIR $APP_HOME
+
+# (Optional but helps some builds)
+ENV CC=gcc CXX=g++
+ENV INSIGHTFACE_HOME=/workspace/cache/insightface
+ENV MPLCONFIGDIR=/workspace/cache/matplotlib
+
+# Python deps
+COPY requirements.txt ./requirements.txt
+
+# Pre-install numpy so headers are ready during builds
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir "numpy<2.0; python_version<'3.12'" "numpy>=2.0; python_version>='3.12'" && \
+    pip install --no-cache-dir -r requirements.txt
+
+# App
+COPY app ./app
+COPY run.sh ./run.sh
+RUN chmod +x ./run.sh
+
+ENV PORT=7860
+CMD ["./run.sh"]

app/deps.py

@@ -0,0 +1,53 @@
+# app/deps.py
+from typing import Optional
+from fastapi import Header
+
+from app.settings import settings
+from app.services.index_store import LocalIndex
+from app.services.face_service import FaceService
+
+# --- SQL agent pieces ---
+from app.tools.sql_tool import SQLTool
+from app.tools.llm_sqlgen import SQLGenTool
+from app.tools.llm_answer import AnswerLLM
+from app.services.agent_sql import SQLAgent
+
+# ---------------- Vector index / Face ----------------
+index = LocalIndex(settings.INDEX_DIR)
+
+providers = settings.PROVIDERS
+if isinstance(providers, str):
+    providers = [p.strip() for p in providers.split(",") if p.strip()]
+face = FaceService(providers=providers)
+
+# ---------------- SQL + Agents (singletons) ----------------
+sql = SQLTool(db_path=settings.SQLITE_PATH)
+sql.setup_demo_enterprise(start="2025-08-10", end="2025-09-10", seed=123)
+
+_sqlgen = SQLGenTool(model_id=settings.LLM_MODEL_ID, token=settings.HF_TOKEN, timeout=settings.TIMEOUT)
+_ansllm = AnswerLLM(model_id=settings.LLM_MODEL_ID, token=settings.HF_TOKEN, timeout=settings.TIMEOUT)
+_sql_agent = SQLAgent(sql=sql, sqlgen=_sqlgen, answer_llm=_ansllm)
+
+
+def get_hf_token(
+    authorization: Optional[str] = Header(None),
+    x_hf_token: Optional[str] = Header(None, convert_underscores=False),
+) -> Optional[str]:
+    if x_hf_token:
+        return x_hf_token.strip()
+    if authorization and authorization.lower().startswith("bearer "):
+        return authorization.split(" ", 1)[1].strip()
+    return None
+
+def build_agent_with_token(hf_token: Optional[str]) -> SQLAgent:
+    """
+    Returns the shared SQLAgent but (temporarily) sets the token when present.
+    Avoids re-instantiating clients for every request.
+    """
+    if hf_token:
+        _sqlgen.set_token(hf_token)
+        _ansllm.set_token(hf_token)
+    else:
+        _sqlgen.set_token(settings.HF_TOKEN)
+        _ansllm.set_token(settings.HF_TOKEN)
+    return _sql_agent

app/main copy.py

@@ -0,0 +1,202 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Query, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from .settings import settings
+from .deps import index, face, get_hf_token, build_agent_with_token
+from .models.face import (
+    EnrollResp, IdentifyReq, IdentifyResp, IdentifyHit,
+    IdentifyManyReq, IdentifyManyResp, FaceDet,
+)
+from .models.query import QueryReq, QueryResp
+from .services.aggregator import aggregate_by_user
+from .services.face_service import imdecode
+import numpy as np, uuid, cv2, os, io, zipfile, glob, shutil
+
+app = FastAPI(title="Realtime BI Assistant")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_credentials=True,
+    allow_methods=["*"], allow_headers=["*"],
+)
+
+@app.get("/")
+def root():
+    return {"ok": True, "msg": "Backend alive"}
+
+def _decide_identity(agg, threshold: float, margin: float):
+    if not agg:
+        return "Unknown", 0.0, 0.0
+    best_user, best_score = agg[0]
+    second = agg[1][1] if len(agg) > 1 else -1.0
+    margin_val = best_score - second
+    if best_score >= threshold and margin_val >= margin and best_user != "Unknown":
+        return best_user, best_score, margin_val
+    return "Unknown", best_score, margin_val
+
+def _safe_extract(zf: zipfile.ZipFile, dest: str):
+    os.makedirs(dest, exist_ok=True)
+    for member in zf.infolist():
+        p = os.path.realpath(os.path.join(dest, member.filename))
+        if not p.startswith(os.path.realpath(dest) + os.sep):
+            continue
+        if member.is_dir():
+            os.makedirs(p, exist_ok=True)
+        else:
+            os.makedirs(os.path.dirname(p), exist_ok=True)
+            with zf.open(member) as src, open(p, "wb") as out:
+                out.write(src.read())
+
+def _guess_images_root(tmpdir: str) -> str | None:
+    pref = os.path.join(tmpdir, "Images")
+    if os.path.isdir(pref):
+        return pref
+    for root, dirs, files in os.walk(tmpdir):
+        subdirs = [os.path.join(root, d) for d in dirs]
+        if subdirs and any(
+            any(fn.lower().endswith((".jpg",".jpeg",".png")) for fn in os.listdir(sd))
+            for sd in subdirs
+        ):
+            return root
+    return None
+
+@app.post("/enroll_zip", response_model=EnrollResp)
+async def enroll_zip(zipfile_upload: UploadFile = File(...)):
+    """
+    Accepts a ZIP with structure: Images/<UserName>/*.jpg|png
+    Upserts all faces into the local FAISS index under user metadata.
+    """
+    if not zipfile_upload.filename.lower().endswith(".zip"):
+        raise HTTPException(400, "Please upload a .zip")
+
+    raw = await zipfile_upload.read()
+    tmpdir = os.path.join("/workspace", "upload", uuid.uuid4().hex[:8])
+    os.makedirs(tmpdir, exist_ok=True)
+    try:
+        with zipfile.ZipFile(io.BytesIO(raw), "r") as zf:
+            _safe_extract(zf, tmpdir)
+
+        root = _guess_images_root(tmpdir)
+        if not root:
+            raise HTTPException(400, "Couldn't find 'Images/<UserName>/*' structure in ZIP")
+
+        user_dirs = sorted([p for p in glob.glob(os.path.join(root, "*")) if os.path.isdir(p)])
+        if not user_dirs:
+            raise HTTPException(400, "No user folders found under Images/")
+
+        total = 0
+        enrolled_users = []
+        for udir in user_dirs:
+            user = os.path.basename(udir)
+            paths = sorted([p for p in glob.glob(os.path.join(udir, "*")) if p.lower().endswith((".jpg",".jpeg",".png"))])
+            if not paths:
+                continue
+            count_user = 0
+            for p in paths:
+                img = cv2.imdecode(np.fromfile(p, dtype=np.uint8), cv2.IMREAD_COLOR)
+                if img is None: continue
+                bbox, emb, det_score = face.embed_best(img)
+                if emb is None: continue
+                vec = emb.astype(np.float32)
+                vec = vec / (np.linalg.norm(vec) + 1e-9)
+                vid = f"{user}::{uuid.uuid4().hex[:8]}"
+                index.add_vectors(vecs=np.array([vec]),
+                                  metas=[{"user":user,"det_score":float(det_score), "source":"enroll_zip"}],
+                                  ids=[vid])
+                count_user += 1
+                total += 1
+            if count_user > 0:
+                enrolled_users.append(user)
+
+        return EnrollResp(users=enrolled_users, total_vectors=total)
+    finally:
+        try:
+            shutil.rmtree(tmpdir, ignore_errors=True)
+        except Exception:
+            pass
+
+# ---------- endpoints ----------
+@app.post("/index/upsert_image")
+async def upsert_image(user: str = Query(..., description="User label"),
+                       image: UploadFile = File(...)):
+    raw = await image.read()
+    img = cv2.imdecode(np.frombuffer(raw, np.uint8), cv2.IMREAD_COLOR)
+    if img is None:
+        raise HTTPException(400, "Invalid image file")
+    bbox, emb, det_score = face.embed_best(img)
+    if emb is None:
+        return {"ok": False, "msg": "no face detected"}
+    vec = emb.astype(np.float32)
+    vec = vec / (np.linalg.norm(vec) + 1e-9)
+    vid = f"{user}::{uuid.uuid4().hex[:8]}"
+    index.add_vectors(vecs=np.array([vec]),
+                      metas=[{"user":user,"det_score":float(det_score)}],
+                      ids=[vid])
+    return {"ok": True, "id": vid, "user": user, "det_score": float(det_score)}
+
+@app.post("/identify", response_model=IdentifyResp)
+async def identify(req: IdentifyReq):
+    try:
+        img = imdecode(req.image_b64)
+    except Exception:
+        raise HTTPException(status_code=400, detail="Bad image_b64")
+    bbox, emb, det_score = face.embed_best(img)
+    if emb is None:
+        return IdentifyResp(decision="NoFace", best_score=0.0, margin=0.0, topk=[], bbox=None)
+
+    matches = index.query(emb, top_k=settings.TOPK_DB)
+    agg = aggregate_by_user(matches)
+
+    user, best, margin_val = _decide_identity(agg, settings.THRESHOLD, settings.MARGIN)
+    topk = [IdentifyHit(user=u, score=s) for u, s in agg[:req.top_k]]
+    return IdentifyResp(decision=user, best_score=best, margin=margin_val, topk=topk, bbox=bbox)
+
+# ---------- NEW: multi-face endpoint ----------
+@app.post("/identify_many", response_model=IdentifyManyResp)
+async def identify_many(req: IdentifyManyReq):
+    try:
+        img = imdecode(req.image_b64)
+    except Exception:
+        raise HTTPException(status_code=400, detail="Bad image_b64")
+
+    faces = face.embed_all(img)
+    if not faces:
+        return IdentifyManyResp(detections=[])
+
+    detections: list[FaceDet] = []
+    top_k_db = req.top_k_db or settings.TOPK_DB
+
+    for bbox, emb, det_score in faces:
+        matches = index.query(emb, top_k=top_k_db)
+        agg = aggregate_by_user(matches)
+        user, best, margin_val = _decide_identity(agg, settings.THRESHOLD, settings.MARGIN)
+        topk = [IdentifyHit(user=u, score=s) for u, s in agg[:req.top_k]]
+        detections.append(FaceDet(
+            bbox=bbox,
+            decision=user,
+            best_score=best,
+            margin=margin_val,
+            topk=topk
+        ))
+
+    return IdentifyManyResp(detections=detections)
+
+@app.post("/query", response_model=QueryResp)
+async def query(req: QueryReq, hf_token: str | None = Depends(get_hf_token)):
+    text = (req.text or "").strip()
+    if not text:
+        raise HTTPException(400, "Empty question")
+
+    sql_agent = build_agent_with_token(hf_token)
+
+    try:
+        answer_text, meta = sql_agent.ask(req.user_id, text)
+        citations = [f"sql:{meta['sql']}"]
+        return QueryResp(
+            answer_text=answer_text,
+            citations=citations,
+            metrics={},
+            chart_refs=[],
+            # uncertainty=0.15
+        )
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Query failed: {e}")

app/main.py

@@ -0,0 +1,414 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Query, Depends, Body
+from fastapi.middleware.cors import CORSMiddleware
+from .settings import settings
+from .deps import index, face, get_hf_token, build_agent_with_token
+from .models.face import (
+    EnrollResp, IdentifyReq, IdentifyResp, IdentifyHit,
+    IdentifyManyReq, IdentifyManyResp, FaceDet,
+)
+from .models.query import QueryReq, QueryResp
+from .services.aggregator import aggregate_by_user
+from .services.face_service import imdecode
+import numpy as np, uuid, cv2, os, io, zipfile, glob, shutil
+import base64, tempfile, subprocess, json
+from typing import Optional, Tuple
+from fastapi.responses import Response, StreamingResponse
+from pydantic import BaseModel
+import soundfile as sf
+import numpy as np
+from pathlib import Path
+
+app = FastAPI(title="Realtime BI Assistant")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_credentials=True,
+    allow_methods=["*"], allow_headers=["*"],
+)
+
+@app.get("/")
+def root():
+    return {"ok": True, "msg": "Backend alive"}
+
+# ---------- Voice config ----------
+STT_PROVIDER = os.getenv("STT_PROVIDER", "offline")  # "offline" | "hf"
+TTS_PROVIDER = os.getenv("TTS_PROVIDER", "offline")  # "offline" | "hf"
+
+# Faster-Whisper (offline STT)
+FW_MODEL_DIR = os.getenv("FW_MODEL_DIR", "/models/faster-whisper")
+FW_MODEL_SIZE = os.getenv("FW_MODEL_SIZE", "small")  # tiny|base|small|medium|large-v3 etc.
+
+# Piper (offline TTS)
+PIPER_BIN = os.getenv("PIPER_BIN", "/usr/local/bin/piper")
+PIPER_VOICE = os.getenv("PIPER_VOICE", "/models/piper/en_US/libri_tts_en_US-medium.onnx")  # change to your voice
+PIPER_SAMPLE_RATE = int(os.getenv("PIPER_SAMPLE_RATE", "22050"))
+
+# Hugging Face (online STT/TTS)
+HF_STT_MODEL = os.getenv("HF_STT_MODEL", "openai/whisper-small")  # any STT model with audio-to-text
+HF_TTS_MODEL = os.getenv("HF_TTS_MODEL", "espnet/kan-bayashi_ljspeech_vits")  # any TTS wav output model
+
+def _ensure_wav_16k_mono(in_bytes: bytes, in_mime: str = "audio/wav") -> Tuple[np.ndarray, int]:
+    """
+    Convert arbitrary audio to mono 16k PCM via ffmpeg, return (float32 PCM, sr=16000).
+    """
+    # Write temp input
+    with tempfile.NamedTemporaryFile(suffix=".input", delete=False) as f_in:
+        f_in.write(in_bytes)
+        in_path = f_in.name
+    out_path = in_path + ".wav"
+
+    # ffmpeg -y -i in -ac 1 -ar 16000 -f wav out
+    cmd = [
+        "ffmpeg", "-y", "-i", in_path,
+        "-ac", "1", "-ar", "16000",
+        "-f", "wav", out_path
+    ]
+    subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+
+    # Load wav
+    data, sr = sf.read(out_path, dtype="float32", always_2d=False)
+    if sr != 16000:
+        raise RuntimeError("ffmpeg resample failed")
+    try:
+        os.remove(in_path)
+        # keep out_path for debug if needed
+    except Exception:
+        pass
+    return data.astype(np.float32), 16000
+
+
+def _bytes_to_wav_stream(pcm: np.ndarray, sr: int = 22050) -> bytes:
+    """Encode float32 PCM to WAV bytes."""
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f_out:
+        sf.write(f_out.name, pcm, sr, subtype="PCM_16")
+        with open(f_out.name, "rb") as fr:
+            wav_bytes = fr.read()
+    try:
+        os.remove(f_out.name)
+    except Exception:
+        pass
+    return wav_bytes
+
+# ---------- STT ----------
+_fw_model = None
+
+def _stt_offline(audio_bytes: bytes, mime: str, hf_token: Optional[str]) -> str:
+    global _fw_model
+    try:
+        from faster_whisper import WhisperModel
+    except Exception as e:
+        raise HTTPException(500, f"faster-whisper not installed: {e}")
+
+    if _fw_model is None:
+        _fw_model = WhisperModel(FW_MODEL_SIZE, device="cpu", compute_type="int8", download_root=FW_MODEL_DIR)
+
+    pcm, _ = _ensure_wav_16k_mono(audio_bytes, mime)
+    # faster-whisper expects path or np array; we’ll pass array
+    segments, info = _fw_model.transcribe(pcm, language=None, beam_size=1, vad_filter=True)
+    text = " ".join([seg.text.strip() for seg in segments]).strip()
+    return text or ""
+
+
+def _stt_hf(audio_bytes: bytes, mime: str, hf_token: Optional[str]) -> str:
+    if not hf_token:
+        raise HTTPException(400, "HF token required for STT via Hugging Face")
+    url = f"https://api-inference.huggingface.co/models/{HF_STT_MODEL}"
+    headers = {"Authorization": f"Bearer {hf_token}"}
+    # HF accepts raw audio bytes
+    import requests as _rq
+    r = _rq.post(url, headers=headers, data=audio_bytes, timeout=120)
+    if not r.ok:
+        raise HTTPException(502, f"HF STT failed: {r.status_code} {r.text[:200]}")
+    try:
+        out = r.json()
+        # common outputs: {"text": "..."} or [{"text": "..."}]
+        if isinstance(out, dict) and "text" in out:
+            return out["text"]
+        if isinstance(out, list) and out and isinstance(out[0], dict) and "text" in out[0]:
+            return out[0]["text"]
+        # some models return {"generated_text": "..."}
+        if isinstance(out, dict) and "generated_text" in out:
+            return out["generated_text"]
+        return ""
+    except Exception:
+        return ""
+
+# ---------- TTS ----------
+def _tts_offline_piper(text: str, voice_path: str) -> bytes:
+    """
+    Call Piper CLI to synthesize WAV.
+    """
+    if not os.path.isfile(voice_path):
+        raise HTTPException(500, f"Piper voice not found at {voice_path}")
+    with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as f_txt:
+        f_txt.write(text.encode("utf-8"))
+        in_txt = f_txt.name
+    out_wav = in_txt + ".wav"
+
+    cmd = [PIPER_BIN, "--model", voice_path, "--output_file", out_wav, "--speaker", "0"]
+    with open(in_txt, "rb") as fin:
+        subprocess.run(cmd, stdin=fin, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+
+    with open(out_wav, "rb") as fr:
+        audio = fr.read()
+    try:
+        os.remove(in_txt)
+        os.remove(out_wav)
+    except Exception:
+        pass
+    return audio
+
+
+def _tts_hf(text: str, hf_token: Optional[str]) -> bytes:
+    if not hf_token:
+        raise HTTPException(400, "HF token required for TTS via Hugging Face")
+    url = f"https://api-inference.huggingface.co/models/{HF_TTS_MODEL}"
+    headers = {"Authorization": f"Bearer {hf_token}", "Accept": "audio/wav", "Content-Type": "application/json"}
+    import requests as _rq
+    r = _rq.post(url, headers=headers, json={"inputs": text}, timeout=120)
+    if not r.ok:
+        # Some HF TTS return JSON with b64; try to parse
+        try:
+            js = r.json()
+            b64 = js.get("audio", None)
+            if b64:
+                return base64.b64decode(b64)
+        except Exception:
+            pass
+        raise HTTPException(502, f"HF TTS failed: {r.status_code} {r.text[:200]}")
+    return r.content
+
+# ---------- Schemas ----------
+class TTSReq(BaseModel):
+    text: str
+    voice: Optional[str] = "en-IN"
+
+
+# ---------- /stt ----------
+@app.post("/stt")
+async def stt(audio: UploadFile = File(...), hf_token: Optional[str] = Depends(get_hf_token)):
+    in_bytes = await audio.read()
+    mime = audio.content_type or "audio/wav"
+
+    if STT_PROVIDER == "offline":
+        text = _stt_offline(in_bytes, mime, hf_token)
+    elif STT_PROVIDER == "hf":
+        text = _stt_hf(in_bytes, mime, hf_token)
+    else:
+        raise HTTPException(400, f"Unknown STT_PROVIDER: {STT_PROVIDER}")
+
+    return {"text": text}
+
+
+# # ---------- /tts ----------
+# @app.post("/tts")
+# async def tts(req: TTSReq, hf_token: Optional[str] = Depends(get_hf_token)):
+#     text = (req.text or "").strip()
+#     if not text:
+#         raise HTTPException(400, "Empty text")
+
+#     if TTS_PROVIDER == "offline":
+#         # You can map req.voice -> multiple piper voices if you have them
+#         audio_bytes = _tts_offline_piper(text, PIPER_VOICE)
+#     elif TTS_PROVIDER == "hf":
+#         audio_bytes = _tts_hf(text, hf_token)
+#     else:
+#         raise HTTPException(400, f"Unknown TTS_PROVIDER: {TTS_PROVIDER}")
+
+#     return Response(content=audio_bytes, media_type="audio/wav")
+VOICE_MAP = {
+    "en-IN": "/models/piper/en_IN/xyz.onnx",
+    "en-US": "/models/piper/en_US/libri_tts_en_US-medium.onnx",
+}
+
+@app.post("/tts")
+async def tts(req: TTSReq, hf_token: Optional[str] = Depends(get_hf_token)):
+    text = (req.text or "").strip()
+    if not text:
+        raise HTTPException(400, "Empty text")
+    if TTS_PROVIDER == "offline":
+        voice_path = VOICE_MAP.get(req.voice, PIPER_VOICE)
+        audio_bytes = _tts_offline_piper(text, voice_path)
+    elif TTS_PROVIDER == "hf":
+        audio_bytes = _tts_hf(text, hf_token)
+    else:
+        raise HTTPException(400, f"Unknown TTS_PROVIDER: {TTS_PROVIDER}")
+    return Response(content=audio_bytes, media_type="audio/wav")
+
+def _decide_identity(agg, threshold: float, margin: float):
+    if not agg:
+        return "Unknown", 0.0, 0.0
+    best_user, best_score = agg[0]
+    second = agg[1][1] if len(agg) > 1 else -1.0
+    margin_val = best_score - second
+    if best_score >= threshold and margin_val >= margin and best_user != "Unknown":
+        return best_user, best_score, margin_val
+    return "Unknown", best_score, margin_val
+
+def _safe_extract(zf: zipfile.ZipFile, dest: str):
+    os.makedirs(dest, exist_ok=True)
+    for member in zf.infolist():
+        p = os.path.realpath(os.path.join(dest, member.filename))
+        if not p.startswith(os.path.realpath(dest) + os.sep):
+            continue
+        if member.is_dir():
+            os.makedirs(p, exist_ok=True)
+        else:
+            os.makedirs(os.path.dirname(p), exist_ok=True)
+            with zf.open(member) as src, open(p, "wb") as out:
+                out.write(src.read())
+
+def _guess_images_root(tmpdir: str) -> str | None:
+    pref = os.path.join(tmpdir, "Images")
+    if os.path.isdir(pref):
+        return pref
+    for root, dirs, files in os.walk(tmpdir):
+        subdirs = [os.path.join(root, d) for d in dirs]
+        if subdirs and any(
+            any(fn.lower().endswith((".jpg",".jpeg",".png")) for fn in os.listdir(sd))
+            for sd in subdirs
+        ):
+            return root
+    return None
+
+@app.post("/enroll_zip", response_model=EnrollResp)
+async def enroll_zip(zipfile_upload: UploadFile = File(...)):
+    """
+    Accepts a ZIP with structure: Images/<UserName>/*.jpg|png
+    Upserts all faces into the local FAISS index under user metadata.
+    """
+    if not zipfile_upload.filename.lower().endswith(".zip"):
+        raise HTTPException(400, "Please upload a .zip")
+
+    raw = await zipfile_upload.read()
+    tmpdir = os.path.join("/workspace", "upload", uuid.uuid4().hex[:8])
+    os.makedirs(tmpdir, exist_ok=True)
+    try:
+        with zipfile.ZipFile(io.BytesIO(raw), "r") as zf:
+            _safe_extract(zf, tmpdir)
+
+        root = _guess_images_root(tmpdir)
+        if not root:
+            raise HTTPException(400, "Couldn't find 'Images/<UserName>/*' structure in ZIP")
+
+        user_dirs = sorted([p for p in glob.glob(os.path.join(root, "*")) if os.path.isdir(p)])
+        if not user_dirs:
+            raise HTTPException(400, "No user folders found under Images/")
+
+        total = 0
+        enrolled_users = []
+        for udir in user_dirs:
+            user = os.path.basename(udir)
+            paths = sorted([p for p in glob.glob(os.path.join(udir, "*")) if p.lower().endswith((".jpg",".jpeg",".png"))])
+            if not paths:
+                continue
+            count_user = 0
+            for p in paths:
+                img = cv2.imdecode(np.fromfile(p, dtype=np.uint8), cv2.IMREAD_COLOR)
+                if img is None: continue
+                bbox, emb, det_score = face.embed_best(img)
+                if emb is None: continue
+                vec = emb.astype(np.float32)
+                vec = vec / (np.linalg.norm(vec) + 1e-9)
+                vid = f"{user}::{uuid.uuid4().hex[:8]}"
+                index.add_vectors(vecs=np.array([vec]),
+                                  metas=[{"user":user,"det_score":float(det_score), "source":"enroll_zip"}],
+                                  ids=[vid])
+                count_user += 1
+                total += 1
+            if count_user > 0:
+                enrolled_users.append(user)
+
+        return EnrollResp(users=enrolled_users, total_vectors=total)
+    finally:
+        try:
+            shutil.rmtree(tmpdir, ignore_errors=True)
+        except Exception:
+            pass
+
+# ---------- endpoints ----------
+@app.post("/index/upsert_image")
+async def upsert_image(user: str = Query(..., description="User label"),
+                       image: UploadFile = File(...)):
+    raw = await image.read()
+    img = cv2.imdecode(np.frombuffer(raw, np.uint8), cv2.IMREAD_COLOR)
+    if img is None:
+        raise HTTPException(400, "Invalid image file")
+    bbox, emb, det_score = face.embed_best(img)
+    if emb is None:
+        return {"ok": False, "msg": "no face detected"}
+    vec = emb.astype(np.float32)
+    vec = vec / (np.linalg.norm(vec) + 1e-9)
+    vid = f"{user}::{uuid.uuid4().hex[:8]}"
+    index.add_vectors(vecs=np.array([vec]),
+                      metas=[{"user":user,"det_score":float(det_score)}],
+                      ids=[vid])
+    return {"ok": True, "id": vid, "user": user, "det_score": float(det_score)}
+
+@app.post("/identify", response_model=IdentifyResp)
+async def identify(req: IdentifyReq):
+    try:
+        img = imdecode(req.image_b64)
+    except Exception:
+        raise HTTPException(status_code=400, detail="Bad image_b64")
+    bbox, emb, det_score = face.embed_best(img)
+    if emb is None:
+        return IdentifyResp(decision="NoFace", best_score=0.0, margin=0.0, topk=[], bbox=None)
+
+    matches = index.query(emb, top_k=settings.TOPK_DB)
+    agg = aggregate_by_user(matches)
+
+    user, best, margin_val = _decide_identity(agg, settings.THRESHOLD, settings.MARGIN)
+    topk = [IdentifyHit(user=u, score=s) for u, s in agg[:req.top_k]]
+    return IdentifyResp(decision=user, best_score=best, margin=margin_val, topk=topk, bbox=bbox)
+
+# ---------- NEW: multi-face endpoint ----------
+@app.post("/identify_many", response_model=IdentifyManyResp)
+async def identify_many(req: IdentifyManyReq):
+    try:
+        img = imdecode(req.image_b64)
+    except Exception:
+        raise HTTPException(status_code=400, detail="Bad image_b64")
+
+    faces = face.embed_all(img)
+    if not faces:
+        return IdentifyManyResp(detections=[])
+
+    detections: list[FaceDet] = []
+    top_k_db = req.top_k_db or settings.TOPK_DB
+
+    for bbox, emb, det_score in faces:
+        matches = index.query(emb, top_k=top_k_db)
+        agg = aggregate_by_user(matches)
+        user, best, margin_val = _decide_identity(agg, settings.THRESHOLD, settings.MARGIN)
+        topk = [IdentifyHit(user=u, score=s) for u, s in agg[:req.top_k]]
+        detections.append(FaceDet(
+            bbox=bbox,
+            decision=user,
+            best_score=best,
+            margin=margin_val,
+            topk=topk
+        ))
+
+    return IdentifyManyResp(detections=detections)
+
+@app.post("/query", response_model=QueryResp)
+async def query(req: QueryReq, hf_token: str | None = Depends(get_hf_token)):
+    text = (req.text or "").strip()
+    if not text:
+        raise HTTPException(400, "Empty question")
+
+    sql_agent = build_agent_with_token(hf_token)
+
+    try:
+        answer_text, meta = sql_agent.ask(req.user_id, text)
+        citations = [f"sql:{meta['sql']}"]
+        return QueryResp(
+            answer_text=answer_text,
+            citations=citations,
+            metrics={},
+            chart_refs=[],
+            # uncertainty=0.15
+        )
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Query failed: {e}")

app/models/face.py

@@ -0,0 +1,37 @@
+# models/face.py
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+class EnrollResp(BaseModel):
+    users: List[str] = Field(default_factory=list)
+    total_vectors: int
+
+class IdentifyReq(BaseModel):
+    image_b64: str
+    top_k: int = 3
+
+class IdentifyHit(BaseModel):
+    user: str
+    score: float
+
+class IdentifyResp(BaseModel):
+    decision: str
+    best_score: float
+    margin: float
+    topk: List[IdentifyHit]
+    bbox: Optional[List[int]] = None
+
+class FaceDet(BaseModel):
+    bbox: List[int]
+    decision: str
+    best_score: float
+    margin: float
+    topk: List[IdentifyHit] = Field(default_factory=list)
+
+class IdentifyManyReq(BaseModel):
+    image_b64: str
+    top_k: int = 3
+    top_k_db: Optional[int] = None
+
+class IdentifyManyResp(BaseModel):
+    detections: List[FaceDet] = Field(default_factory=list)

app/models/query.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, Field
+from typing import Any, Dict, List, Optional
+
+class QueryReq(BaseModel):
+    user_id: Optional[str] = None
+    text: str
+    visual_ctx: Optional[Dict[str, Any]] = Field(
+        default=None,
+        json_schema_extra={"example": {}},
+    )
+
+class QueryResp(BaseModel):
+    answer_text: str
+    citations: List[str] = Field(default_factory=list)
+    metrics: Dict[str, Any] = Field(default_factory=dict)
+    chart_refs: List[str] = Field(default_factory=list)
+    # uncertainty: float = 0.0

app/services/agent_sql.py

@@ -0,0 +1,22 @@
+# app/services/agent_sql.py
+from typing import Dict, Any, Tuple
+from app.tools.sql_tool import SQLTool
+from app.tools.llm_sqlgen import SQLGenTool
+from app.tools.llm_answer import AnswerLLM
+
+class SQLAgent:
+    def __init__(self, sql: SQLTool, sqlgen: SQLGenTool, answer_llm: AnswerLLM):
+        self.sql = sql
+        self.sqlgen = sqlgen
+        self.answer_llm = answer_llm
+
+    def ask(self, user_id: str | None, question: str) -> Tuple[str, Dict[str, Any]]:
+        sql = self.sqlgen.generate_sql(question)
+        result = self.sql.execute_sql_readonly(sql)
+        answer = self.answer_llm.generate(question, sql, result["columns"], result["rows"])
+        meta = {
+            "sql": sql,
+            "rowcount": result["rowcount"],
+            "columns": result["columns"],
+        }
+        return answer, meta

app/services/aggregator.py

@@ -0,0 +1,11 @@
+from collections import defaultdict
+import numpy as np
+
+def aggregate_by_user(matches):
+    per_user = defaultdict(list)
+    for m in matches:
+        u = (m.get("metadata") or {}).get("user", "Unknown")
+        per_user[u].append(m["score"])
+    agg = [(u, float(np.max(v))) for u, v in per_user.items()]
+    agg.sort(key=lambda x: x[1], reverse=True)
+    return agg

app/services/face_service.py

@@ -0,0 +1,48 @@
+# services/face_service.py
+import os, base64, cv2, numpy as np
+
+os.environ.setdefault("HOME", "/workspace")
+os.environ.setdefault("INSIGHTFACE_HOME", "/workspace/cache/insightface")
+os.environ.setdefault("MPLCONFIGDIR", "/workspace/cache/matplotlib")
+os.makedirs(os.environ["INSIGHTFACE_HOME"], exist_ok=True)
+os.makedirs(os.environ["MPLCONFIGDIR"], exist_ok=True)
+
+from insightface.app import FaceAnalysis
+
+def imdecode(b64: str):
+    raw = base64.b64decode(b64)
+    arr = np.frombuffer(raw, np.uint8)
+    img = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    if img is None:
+        raise ValueError("Bad image_b64")
+    return img
+
+class FaceService:
+    def __init__(self, providers):
+        cache_root = os.environ["INSIGHTFACE_HOME"]
+        self.app = FaceAnalysis(
+            name="buffalo_l",
+            providers=providers,
+            root=cache_root,
+        )
+        self.app.prepare(ctx_id=0, det_size=(640, 640))
+
+    def embed_best(self, img_bgr):
+        faces = self.app.get(img_bgr)
+        if not faces:
+            return None, None, None
+        best = max(faces, key=lambda f: (f.bbox[2]-f.bbox[0])*(f.bbox[3]-f.bbox[1]))
+        bbox = best.bbox.astype(int).tolist()
+        emb  = best.normed_embedding
+        score = float(getattr(best, 'det_score', 1.0))
+        return bbox, emb, score
+
+    def embed_all(self, img_bgr):
+        faces = self.app.get(img_bgr)
+        out = []
+        for f in faces:
+            bbox = f.bbox.astype(int).tolist()
+            emb = f.normed_embedding
+            score = float(getattr(f, 'det_score', 1.0))
+            out.append((bbox, emb, score))
+        return out

app/services/index_store.py

@@ -0,0 +1,49 @@
+import os, json
+import numpy as np
+import faiss
+
+class LocalIndex:
+    def __init__(self, index_dir: str):
+        self.index_dir = index_dir
+        self.index_path = os.path.join(index_dir, "faiss.index")
+        self.ids_path   = os.path.join(index_dir, "ids.npy")
+        self.meta_path  = os.path.join(index_dir, "meta.json")
+
+        if os.path.exists(self.index_path) and os.path.exists(self.ids_path) and os.path.exists(self.meta_path):
+            self.index = faiss.read_index(self.index_path)
+            self.local_ids = list(np.load(self.ids_path, allow_pickle=True))
+            with open(self.meta_path, "r") as f:
+                self.local_meta = json.load(f)
+        else:
+            self.index = faiss.IndexFlatIP(512)
+            self.local_ids = []
+            self.local_meta = {}
+            self._persist()
+
+    def _persist(self):
+        faiss.write_index(self.index, self.index_path)
+        np.save(self.ids_path, np.array(self.local_ids, dtype=object), allow_pickle=True)
+        with open(self.meta_path, "w") as f:
+            json.dump(self.local_meta, f)
+
+    def add_vectors(self, vecs: np.ndarray, metas: list, ids: list):
+        vecs = vecs.astype(np.float32)
+        norms = np.linalg.norm(vecs, axis=1, keepdims=True) + 1e-9
+        vecs = vecs / norms
+        self.index.add(vecs)
+        for vid, meta in zip(ids, metas):
+            self.local_ids.append(vid)
+            self.local_meta[vid] = meta
+        self._persist()
+
+    def query(self, emb: np.ndarray, top_k: int):
+        q = emb.astype(np.float32)
+        q = q / (np.linalg.norm(q) + 1e-9)
+        D, I = self.index.search(q.reshape(1, -1), top_k)
+        out = []
+        for score, idx in zip(D[0], I[0]):
+            if idx == -1:
+                continue
+            vid = self.local_ids[idx]
+            out.append({"id": vid, "score": float(score), "metadata": dict(self.local_meta.get(vid, {}))})
+        return out

app/settings.py

@@ -0,0 +1,41 @@
+from typing import List, Optional
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import Field, AliasChoices, computed_field
+import json, os
+
+# ensure sane defaults for caches
+os.environ.setdefault("HOME", "/workspace")
+os.environ.setdefault("INSIGHTFACE_HOME", "/workspace/cache/insightface")
+os.environ.setdefault("MPLCONFIGDIR", "/workspace/cache/matplotlib")
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+    INDEX_DIR: str = "/workspace/data/index"
+    CACHE_DIR: str = "/workspace/cache"
+    THRESHOLD: float = 0.50
+    MARGIN: float = 0.05
+    TIMEOUT: int = 180
+    TOPK_DB: int = 20
+    TOPK_SHOW: int = 3
+    SQLITE_PATH: str = "/workspace/data/demo.db"
+
+    LLM_MODEL_ID: str = "google/gemma-3-27b-it"
+    HF_TOKEN: Optional[str] = None
+    LLM_MAX_NEW_TOKENS: int = 200
+    LLM_TEMPERATURE: float = 0.2
+
+    PROVIDERS_RAW: Optional[str] = Field(default=None, validation_alias=AliasChoices("PROVIDERS"))
+
+    @computed_field(return_type=List[str])
+    @property
+    def PROVIDERS(self) -> List[str]:
+        s = (self.PROVIDERS_RAW or "").strip()
+        if not s:
+            return ["CPUExecutionProvider"]
+        if s.startswith("["):
+            return json.loads(s)
+        return [p.strip() for p in s.split(",") if p.strip()]
+
+settings = Settings()
+os.makedirs(settings.INDEX_DIR, exist_ok=True)
+os.makedirs(settings.CACHE_DIR, exist_ok=True)

app/tools/llm_answer.py

@@ -0,0 +1,50 @@
+# app/tools/llm_answer.py
+from __future__ import annotations
+from typing import Optional, Dict, Any, List
+import requests, json
+
+HF_CHAT_URL = "https://router.huggingface.co/featherless-ai/v1/chat/completions"
+
+SYSTEM_PROMPT = """You are a BI copilot.
+- NEVER invent numbers; only summarize from provided table rows.
+- Use 3-letter region codes (NCR, BLR, MUM, HYD, CHN, PUN).
+- Write one concise paragraph and up to 2 brief bullets with clear takeaways.
+- If you donot get any response then just say that donot invent anything new.
+"""
+
+class AnswerLLM:
+    def __init__(self, model_id: str, token: Optional[str], temperature: float = 0.2, max_tokens: int = 300, timeout: int = 60):
+        self.model_id = model_id
+        self.token = token
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.timeout = timeout
+        self.enabled = bool(token and model_id)
+
+    def set_token(self, token: Optional[str]) -> None:
+        self.token = token
+        self.enabled = bool(token and self.model_id)
+
+    def generate(self, question: str, sql: str, columns: List[str], rows: List[list]) -> str:
+        if not self.enabled:
+            # deterministic fallback
+            return f"Rows: {len(rows)} | Columns: {columns[:4]}..."
+        # keep rows small in prompt; if big, sample top-N
+        preview = rows if len(rows) <= 50 else rows[:50]
+        table_json = json.dumps({"columns": columns, "rows": preview}, ensure_ascii=False)
+        payload = {
+            "model": self.model_id,
+            "stream": False,
+            "messages": [
+                {"role":"system", "content":[{"type":"text","text":SYSTEM_PROMPT}]},
+                {"role":"user", "content":[
+                    {"type":"text","text": f"Question: {question}\nSQL used:\n{sql}\n\nHere are the rows (JSON):\n{table_json}\n\nAnswer:"}
+                ]},
+            ],
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+        }
+        headers = {"Authorization": f"Bearer {self.token}"}
+        r = requests.post(HF_CHAT_URL, headers=headers, json=payload, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()["choices"][0]["message"]["content"]

app/tools/llm_sqlgen.py

@@ -0,0 +1,103 @@
+# app/tools/llm_sqlgen.py
+from __future__ import annotations
+from typing import Optional, Dict, Any
+import requests, json
+
+HF_CHAT_URL = "https://router.huggingface.co/featherless-ai/v1/chat/completions"
+
+SCHEMA_SPEC = """
+Tables and columns (SQLite):
+
+dim_region(code, name)
+dim_product(sku, category, name, price)
+dim_employee(emp_id, name, region_code, role, hire_date)
+
+fact_sales(day, region_code, sku, channel, units, revenue)
+fact_sales_detail(day, region_code, sku, channel, employee_id, units, revenue)
+
+inv_stock(day, region_code, sku, on_hand_qty)
+
+Rules:
+- Use only SELECT. Never modify data.
+- Prefer ISO date literals 'YYYY-MM-DD'.
+- Region codes are 3 letters: NCR, BLR, MUM, HYD, CHN, PUN.
+- For monthly rollups use strftime('%Y-%m', day).
+- Join to dim_product when you need category/name/price.
+- For per-employee metrics use fact_sales_detail (employee_id may be NULL for Online).
+"""
+
+FEW_SHOTS = [
+    {
+        "q": "What is monthly revenue for Electronics in BLR for 2025-09?",
+        "sql": """SELECT strftime('%Y-%m', fs.day) AS month, SUM(fs.revenue) AS revenue
+FROM fact_sales fs
+JOIN dim_product p ON p.sku = fs.sku
+WHERE fs.region_code='BLR' AND p.category='Electronics' AND fs.day BETWEEN '2025-09-01' AND '2025-09-30'
+GROUP BY month
+ORDER BY month"""
+    },
+    {
+        "q": "Show Ramesh's sales (units and revenue) in NCR on 2025-09-06",
+        "sql": """SELECT e.name, d.units, d.revenue
+FROM fact_sales_detail d
+JOIN dim_employee e ON e.emp_id = d.employee_id
+WHERE e.name LIKE 'Ramesh %' AND d.region_code='NCR' AND d.day='2025-09-06'"""
+    },
+    {
+        "q": "What's the on-hand stock for sku ELEC-002 in MUM on 2025-09-05?",
+        "sql": """SELECT on_hand_qty
+FROM inv_stock
+WHERE region_code='MUM' AND sku='ELEC-002' AND day='2025-09-05'"""
+    },
+    {
+        "q": "Top 5 SKUs by revenue in HYD on 2025-09-06 (include category)",
+        "sql": """SELECT fs.sku, p.category, SUM(fs.revenue) AS rev
+FROM fact_sales fs
+JOIN dim_product p ON p.sku=fs.sku
+WHERE fs.region_code='HYD' AND fs.day='2025-09-06'
+GROUP BY fs.sku, p.category
+ORDER BY rev DESC
+LIMIT 5"""
+    }
+]
+
+class SQLGenTool:
+    def __init__(self, model_id: str, token: Optional[str], temperature: float = 0.0, max_tokens: int = 400, timeout: int = 60):
+        self.model_id = model_id
+        self.token = token
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.timeout = timeout
+        self.enabled = bool(token and model_id)
+
+    def set_token(self, token: Optional[str]) -> None:
+        self.token = token
+        self.enabled = bool(token and self.model_id)
+
+    def generate_sql(self, question: str) -> str:
+        if not self.enabled:
+            raise RuntimeError("SQLGenTool disabled: missing HF token or model_id.")
+        fewshot_txt = "\n".join([f"Q: {ex['q']}\nSQL:\n{ex['sql']}\n" for ex in FEW_SHOTS])
+        sys = (
+            "You are a SQL generator. Output only a single JSON object: {\"sql\": \"...\"}.\n"
+            "No prose. No explanations. Use the provided schema only.\n" + SCHEMA_SPEC
+        )
+        user = f"Question:\n{question}\n\nReturn JSON with a single key 'sql'."
+        payload = {
+            "model": self.model_id,
+            "stream": False,
+            "messages": [
+                {"role":"system","content":[{"type":"text","text":sys}]},
+                {"role":"user","content":[{"type":"text","text":fewshot_txt + "\n\n" + user}]},
+            ],
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+        }
+        headers = {"Authorization": f"Bearer {self.token}"}
+        r = requests.post(HF_CHAT_URL, headers=headers, json=payload, timeout=self.timeout)
+        r.raise_for_status()
+        content = r.json()["choices"][0]["message"]["content"].strip()
+        s, e = content.find("{"), content.rfind("}")
+        obj = json.loads(content[s:e+1])
+        sql = obj.get("sql","").strip()
+        return sql

app/tools/sql_tool.py

@@ -0,0 +1,300 @@
+# app/tools/sql_tool.py
+import os, sqlite3, random, math, string
+from datetime import date, timedelta
+from typing import Optional, Dict, Any, List, Tuple
+
+REGIONS: List[Tuple[str, str]] = [
+    ("NCR", "Delhi NCR"),
+    ("BLR", "Bengaluru"),
+    ("MUM", "Mumbai"),
+    ("HYD", "Hyderabad"),
+    ("CHN", "Chennai"),
+    ("PUN", "Pune"),
+]
+
+PRODUCTS: List[Tuple[str, str, str, float]] = [
+    ("ELEC-001", "Electronics", "Smartphone Alpha", 29999.0),
+    ("ELEC-002", "Electronics", "Smartphone Pro",   49999.0),
+    ("ELEC-003", "Electronics", "Laptop 14\"",      65999.0),
+    ("ELEC-004", "Electronics", "Earbuds",           3999.0),
+    ("APP-001",  "Apparel",     "Athleisure Tee",     999.0),
+    ("APP-002",  "Apparel",     "Formal Shirt",      1599.0),
+    ("APP-003",  "Apparel",     "Denim Jeans",       2499.0),
+    ("GROC-001", "Grocery",     "Olive Oil 1L",       799.0),
+    ("GROC-002", "Grocery",     "Basmati 5kg",       899.0),
+    ("GROC-003", "Grocery",     "Almonds 1kg",      1199.0),
+    ("HOME-001", "Home",        "Mixer Grinder",     3499.0),
+    ("HOME-002", "Home",        "Air Fryer",         6999.0),
+]
+
+def _rand_name(rnd: random.Random):
+    first = ["Ramesh","Suresh","Mahesh","Amit","Priya","Anita","Kiran","Sunil","Neha","Pooja","Ravi","Vijay","Anil","Meera","Tarun"]
+    last  = ["Kumar","Sharma","Patel","Verma","Reddy","Iyer","Das","Ghosh","Yadav","Gupta","Singh","Menon"]
+    return f"{rnd.choice(first)} {rnd.choice(last)}"
+
+class SQLTool:
+    """
+    Enterprise-ish SQLite schema with dims/facts and safe read-only SQL execution.
+
+      dim_region(code, name)
+      dim_product(sku, category, name, price)
+      dim_employee(emp_id, name, region_code, role, hire_date)
+
+      fact_sales(day, region_code, sku, channel, units, revenue)          -- daily aggregates
+      fact_sales_detail(day, region_code, sku, channel, employee_id, units, revenue)  -- retail split by employee
+
+      inv_stock(day, region_code, sku, on_hand_qty)
+    """
+
+    def __init__(self, db_path: Optional[str] = None):
+        path = db_path or os.getenv("SQLITE_PATH", ":memory:")
+        self.path = path
+        self.conn = sqlite3.connect(path, check_same_thread=False)
+        self.conn.execute("PRAGMA journal_mode=WAL;")
+        self.conn.execute("PRAGMA synchronous=NORMAL;")
+
+    # ---------------------- schema & seed ----------------------
+    def setup_demo_enterprise(self, start: str = "2025-08-10", end: str = "2025-09-10", seed: int = 42):
+        cur = self.conn.cursor()
+        cur.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS dim_region (
+              code TEXT PRIMARY KEY,
+              name TEXT NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS dim_product (
+              sku TEXT PRIMARY KEY,
+              category TEXT NOT NULL,
+              name TEXT NOT NULL,
+              price REAL NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS dim_employee (
+              emp_id TEXT PRIMARY KEY,
+              name TEXT NOT NULL,
+              region_code TEXT NOT NULL REFERENCES dim_region(code),
+              role TEXT NOT NULL,
+              hire_date TEXT NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS fact_sales (
+              day TEXT NOT NULL,
+              region_code TEXT NOT NULL REFERENCES dim_region(code),
+              sku TEXT NOT NULL REFERENCES dim_product(sku),
+              channel TEXT NOT NULL,
+              units INTEGER NOT NULL,
+              revenue REAL NOT NULL,
+              PRIMARY KEY (day, region_code, sku, channel)
+            );
+            CREATE TABLE IF NOT EXISTS fact_sales_detail (
+              day TEXT NOT NULL,
+              region_code TEXT NOT NULL REFERENCES dim_region(code),
+              sku TEXT NOT NULL REFERENCES dim_product(sku),
+              channel TEXT NOT NULL,
+              employee_id TEXT NULL REFERENCES dim_employee(emp_id),
+              units INTEGER NOT NULL,
+              revenue REAL NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS inv_stock (
+              day TEXT NOT NULL,
+              region_code TEXT NOT NULL REFERENCES dim_region(code),
+              sku TEXT NOT NULL REFERENCES dim_product(sku),
+              on_hand_qty INTEGER NOT NULL,
+              PRIMARY KEY (day, region_code, sku)
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_sales_day          ON fact_sales(day);
+            CREATE INDEX IF NOT EXISTS idx_sales_region       ON fact_sales(region_code);
+            CREATE INDEX IF NOT EXISTS idx_sales_sku          ON fact_sales(sku);
+            CREATE INDEX IF NOT EXISTS idx_sales_day_region   ON fact_sales(day, region_code);
+
+            CREATE INDEX IF NOT EXISTS idx_detail_day_region  ON fact_sales_detail(day, region_code);
+            CREATE INDEX IF NOT EXISTS idx_detail_emp         ON fact_sales_detail(employee_id);
+
+            CREATE INDEX IF NOT EXISTS idx_stock_day_region   ON inv_stock(day, region_code);
+            """
+        )
+
+        existing = set(r[0] for r in cur.execute("SELECT code FROM dim_region"))
+        to_ins = [(c, n) for c, n in REGIONS if c not in existing]
+        if to_ins:
+            cur.executemany("INSERT INTO dim_region(code, name) VALUES (?,?)", to_ins)
+
+        existing_sku = set(r[0] for r in cur.execute("SELECT sku FROM dim_product"))
+        to_ins_p = [p for p in PRODUCTS if p[0] not in existing_sku]
+        if to_ins_p:
+            cur.executemany("INSERT INTO dim_product(sku, category, name, price) VALUES (?,?,?,?)", to_ins_p)
+
+        emp_count = cur.execute("SELECT COUNT(*) FROM dim_employee").fetchone()[0]
+        rnd = random.Random(seed)
+        if emp_count == 0:
+            rows = []
+            for code, _ in REGIONS:
+                n = 8
+                for _ in range(n):
+                    emp_id = f"E{code}{rnd.randint(1000,9999)}"
+                    rows.append((emp_id, _rand_name(rnd), code, rnd.choice(["AE","SE","AM"]), "2023-01-01"))
+            cur.executemany("INSERT INTO dim_employee(emp_id,name,region_code,role,hire_date) VALUES (?,?,?,?,?)", rows)
+
+        n_sales = cur.execute("SELECT COUNT(*) FROM fact_sales").fetchone()[0]
+        if n_sales == 0:
+            self._seed_fact_sales(cur, start, end, seed)
+
+        n_detail = cur.execute("SELECT COUNT(*) FROM fact_sales_detail").fetchone()[0]
+        if n_detail == 0:
+            self._seed_sales_detail(cur, seed)
+
+        n_stock = cur.execute("SELECT COUNT(*) FROM inv_stock").fetchone()[0]
+        if n_stock == 0:
+            self._seed_stock(cur, start, end, seed)
+
+        self.conn.commit()
+
+    def _seed_fact_sales(self, cur: sqlite3.Cursor, start: str, end: str, seed: int):
+        rnd = random.Random(seed)
+        start_d = date.fromisoformat(start)
+        end_d = date.fromisoformat(end)
+        days = (end_d - start_d).days + 1
+        region_factor = {"NCR":1.25,"MUM":1.15,"BLR":1.10,"HYD":0.95,"CHN":0.90,"PUN":0.85}
+        channels = ["Online","Retail"]
+
+        batch = []
+        for i in range(days):
+            d = (start_d + timedelta(days=i)).isoformat()
+            wknd = (start_d + timedelta(days=i)).weekday() >= 5
+            wknd_boost = 1.10 if wknd else 1.0
+            for code, _name in REGIONS:
+                rfac = region_factor[code]
+                for sku, category, _nm, price in PRODUCTS:
+                    for ch in channels:
+                        base = {"Electronics":12,"Apparel":25,"Grocery":40,"Home":9}[category]
+                        ch_mult = 1.15 if ch == "Online" else 0.95
+                        mu = base * rfac * wknd_boost * ch_mult
+                        sigma = max(1.0, mu * 0.25)
+                        units = max(0, int(rnd.gauss(mu, sigma)))
+                        season = 1.0 + 0.08 * math.sin(i / 3.5)
+                        revenue = round(units * price * season, 2)
+                        batch.append((d, code, sku, ch, units, revenue))
+        cur.executemany(
+            "INSERT INTO fact_sales(day, region_code, sku, channel, units, revenue) VALUES (?,?,?,?,?,?)",
+            batch
+        )
+
+    def _seed_sales_detail(self, cur: sqlite3.Cursor, seed: int):
+        rnd = random.Random(seed+7)
+        rows = cur.execute(
+            "SELECT day, region_code, sku, units, revenue FROM fact_sales WHERE channel='Retail'"
+        ).fetchall()
+
+        for d, region, sku, units, revenue in rows:
+            if units == 0:
+                continue
+            emp_ids = [r[0] for r in cur.execute("SELECT emp_id FROM dim_employee WHERE region_code=?", (region,))]
+            parts = rnd.randint(1, min(4, max(1, units)))
+            cuts = sorted(rnd.sample(range(1, units), parts-1)) if units > parts else []
+            splits = [b-a for a,b in zip([0]+cuts, cuts+[units])]
+            total_units = float(sum(splits))
+            rev_splits = [round(revenue * (u/total_units), 2) for u in splits]
+            if rev_splits:
+                drift = round(revenue - sum(rev_splits), 2)
+                rev_splits[0] += drift
+            for u, r in zip(splits, rev_splits):
+                emp = rnd.choice(emp_ids) if emp_ids else None
+                cur.execute(
+                    "INSERT INTO fact_sales_detail(day, region_code, sku, channel, employee_id, units, revenue) "
+                    "VALUES (?,?,?,?,?,?,?)",
+                    (d, region, sku, "Retail", emp, u, r)
+                )
+
+    def _seed_stock(self, cur: sqlite3.Cursor, start: str, end: str, seed: int):
+        rnd = random.Random(seed+13)
+        start_d = date.fromisoformat(start)
+        end_d = date.fromisoformat(end)
+        days = (end_d - start_d).days + 1
+
+        for i in range(days):
+            d = (start_d + timedelta(days=i)).isoformat()
+            for code, _ in REGIONS:
+                for sku, category, _nm, _price in PRODUCTS:
+                    base = {"Electronics":400,"Apparel":800,"Grocery":600,"Home":300}[category]
+                    noise = rnd.randint(-30, 30)
+                    on_hand = max(0, base + noise - i*2)
+                    cur.execute(
+                        "INSERT INTO inv_stock(day, region_code, sku, on_hand_qty) VALUES (?,?,?,?)",
+                        (d, code, sku, on_hand)
+                    )
+
+    # ---------------------- helpers + read-only executor ----------------------
+    def region_codes(self) -> List[str]:
+        rows = self.conn.execute("SELECT code FROM dim_region").fetchall()
+        return [r[0] for r in rows]
+
+    def execute_sql_readonly(self, sql: str) -> Dict[str, Any]:
+        """Hard safety: allow only a single SELECT statement; no comments/CTEs with semicolons."""
+        s = sql.strip()
+        bad = (";", "--", "/*", "*/")
+        if not s.lower().startswith("select"):
+            raise ValueError("Only SELECT statements are allowed.")
+        if any(tok in s for tok in bad):
+            raise ValueError("Disallowed token in SQL.")
+        cur = self.conn.cursor()
+        cur.execute(s)
+        cols = [d[0] for d in cur.description] if cur.description else []
+        rows = cur.fetchall()
+        return {"columns": cols, "rows": rows, "rowcount": len(rows)}
+
+if __name__ == "__main__":
+    import argparse
+    import os
+    import sys
+    from pathlib import Path
+
+    parser = argparse.ArgumentParser(
+        description="Create and persist the demo enterprise SQLite database."
+    )
+    parser.add_argument(
+        "--db",
+        default=os.getenv("SQLITE_PATH", "./demo_enterprise.sqlite"),
+        help="Path to the SQLite DB file to create (defaults to ./demo_enterprise.sqlite or $SQLITE_PATH).",
+    )
+    parser.add_argument(
+        "--start",
+        default="2025-08-10",
+        help="Start date (YYYY-MM-DD) for seeding data.",
+    )
+    parser.add_argument(
+        "--end",
+        default="2025-09-10",
+        help="End date (YYYY-MM-DD) for seeding data.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed used for deterministic seeding.",
+    )
+    args = parser.parse_args()
+
+    # Ensure we persist to disk (avoid in-memory DB).
+    db_path = args.db
+    if db_path == ":memory:":
+        print("':memory:' was requested; switching to ./demo_enterprise.sqlite so the DB is saved to disk.")
+        db_path = "./demo_enterprise.db"
+
+    # Make sure the parent directory exists
+    parent = Path(db_path).expanduser().resolve().parent
+    parent.mkdir(parents=True, exist_ok=True)
+
+    tool = SQLTool(db_path=str(Path(db_path).expanduser()))
+    tool.setup_demo_enterprise(start=args.start, end=args.end, seed=args.seed)
+
+    # Flush and close
+    tool.conn.commit()
+    tool.conn.close()
+
+    print(f"✅ Database created at: {Path(db_path).expanduser().resolve()}")
+    print(f"   Seed window: {args.start} → {args.end} | seed={args.seed}")
+
+# # Default location ./demo_enterprise.sqlite
+# python app/tools/sql_tool.py
+
+# # Custom location and date range
+# python BI_Assistant_Backend/app/tools/sql_tool.py --db ./data/retail_demo.sqlite --start 2025-08-01 --end 2025-09-10 --seed 123

requirements.txt

@@ -0,0 +1,14 @@
+fastapi
+uvicorn
+pydantic
+pydantic-settings
+numpy==1.26.4
+faiss-cpu
+insightface==0.7.3
+# onnxruntime
+onnxruntime==1.17.3
+opencv-python==4.10.0.84
+python-multipart
+requests
+Pillow
+huggingface_hub

run.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PYTHONUNBUFFERED=1
+
+# If user sets PROVIDERS env, use it; else default to CPU provider
+export PROVIDERS="${PROVIDERS:-CPUExecutionProvider}"
+export INSIGHTFACE_HOME=/workspace/cache/insightface
+export MPLCONFIGDIR=/workspace/cache/matplotlib
+
+mkdir -p "$INSIGHTFACE_HOME" "$MPLCONFIGDIR"
+
+# Start FastAPI
+uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}