Add Milestone 9 for Streamlit UI Integration

Introduce Milestone 9 in milestones.md, detailing the integration of Streamlit UI with the backend API. Update dependencies in pyproject.toml and requirements.txt to include Streamlit. Enhance the uv.lock file with new package entries and ensure the backend server setup instructions are clear for both FastAPI and Streamlit. Verification checks and pass criteria for the UI flow are also defined.

pyproject.toml

@@ -24,6 +24,7 @@ dependencies = [
     "uvicorn[standard]==0.29.0",
     "huggingface-hub>=1.13.0",
     "langchain-huggingface>=0.0.3",
+    "streamlit>=1.39.0",
     "onnxruntime==1.23.2 ; sys_platform == 'darwin' and platform_machine == 'x86_64'",
     "torch==2.2.2 ; sys_platform == 'darwin' and platform_machine == 'x86_64'",
 ]

requirements.txt

@@ -16,4 +16,5 @@ python-multipart==0.0.9
 aiosqlite
 httpx>=0.27.0
 huggingface-hub 
-langchain-huggingface
+langchain-huggingface
+streamlit>=1.39.0

streamlit_app.py

@@ -0,0 +1,355 @@
+"""Streamlit UI for doc-audi-ai — talks to the FastAPI backend only."""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import Any
+
+import httpx
+import streamlit as st
+
+DEFAULT_API_BASE = os.environ.get("DOC_AUDI_API_BASE", "http://127.0.0.1:8000")
+HTTP_TIMEOUT = httpx.Timeout(120.0, connect=10.0)
+
+
+def _api_base() -> str:
+    return (st.session_state.get("api_base") or DEFAULT_API_BASE).rstrip("/")
+
+
+def _client() -> httpx.Client:
+    return httpx.Client(base_url=_api_base(), timeout=HTTP_TIMEOUT)
+
+
+def _fmt_api_error(exc: httpx.HTTPStatusError) -> str:
+    try:
+        body = exc.response.json()
+    except Exception:
+        return f"HTTP {exc.response.status_code}: {exc.response.text[:500]}"
+    detail = body.get("detail")
+    if isinstance(detail, list):
+        parts = []
+        for item in detail:
+            if isinstance(item, dict):
+                loc = item.get("loc", ())
+                msg = item.get("msg", "")
+                parts.append(f"{'/'.join(str(x) for x in loc)}: {msg}")
+            else:
+                parts.append(str(item))
+        return f"HTTP {exc.response.status_code}: " + "; ".join(parts)
+    if detail is not None:
+        return f"HTTP {exc.response.status_code}: {detail}"
+    return f"HTTP {exc.response.status_code}"
+
+
+def _health_check() -> tuple[bool, str]:
+    try:
+        with _client() as c:
+            r = c.get("/health")
+            r.raise_for_status()
+            data = r.json()
+            return True, str(data)
+    except httpx.ConnectError as e:
+        return False, f"Cannot connect to {_api_base()}: {e}"
+    except httpx.HTTPStatusError as e:
+        return False, _fmt_api_error(e)
+    except Exception as e:
+        return False, str(e)
+
+
+def main() -> None:
+    st.set_page_config(page_title="doc-audi-ai", layout="wide")
+    st.title("doc-audi-ai")
+    st.caption("Ingest, query, and audit via the FastAPI backend.")
+
+    if "api_base" not in st.session_state:
+        st.session_state.api_base = DEFAULT_API_BASE
+
+    with st.sidebar:
+        st.subheader("Backend")
+        st.text_input("API base URL", key="api_base")
+        if st.button("Test connection"):
+            ok, msg = _health_check()
+            if ok:
+                st.success(msg)
+            else:
+                st.error(msg)
+
+    tab_upload, tab_jobs, tab_ask, tab_sum, tab_audit = st.tabs(
+        ["Upload", "Jobs", "Ask", "Summarise", "Audit"]
+    )
+
+    with tab_upload:
+        st.subheader("Upload document")
+        col_u1, col_u2 = st.columns(2)
+        with col_u1:
+            up_collection = st.text_input("Collection", value="default", key="up_col")
+            uploaded = st.file_uploader("PDF, TXT, or Markdown", type=["pdf", "txt", "md"], key="up_file")
+        with col_u2:
+            if st.button("Submit upload", key="btn_upload", disabled=uploaded is None):
+                if uploaded is None:
+                    st.warning("Choose a file first.")
+                else:
+                    try:
+                        files = {"file": (uploaded.name, uploaded.getvalue(), uploaded.type or "application/octet-stream")}
+                        data = {"collection_name": up_collection}
+                        with _client() as c:
+                            r = c.post("/ingest/upload", files=files, data=data)
+                            r.raise_for_status()
+                            out = r.json()
+                        st.success(out.get("message", "Queued"))
+                        st.json(out)
+                        if out.get("job_id"):
+                            st.session_state["last_job_id"] = out["job_id"]
+                    except httpx.HTTPStatusError as e:
+                        st.error(_fmt_api_error(e))
+                    except httpx.ConnectError as e:
+                        st.error(f"Connection failed: {e}")
+                    except Exception as e:
+                        st.exception(e)
+
+        st.subheader("Ingest from URL")
+        url_col = st.columns([3, 1])
+        with url_col[0]:
+            ingest_url = st.text_input("Document URL (http/https)", key="ingest_url")
+        with url_col[1]:
+            url_collection = st.text_input("Collection", value="default", key="url_col")
+        if st.button("Queue URL ingest", key="btn_url"):
+            if not ingest_url.strip():
+                st.warning("Enter a URL.")
+            else:
+                try:
+                    with _client() as c:
+                        r = c.post("/ingest/url", json={"url": ingest_url.strip(), "collection_name": url_collection})
+                        r.raise_for_status()
+                        out = r.json()
+                    st.success(out.get("message", "Queued"))
+                    st.json(out)
+                    if out.get("job_id"):
+                        st.session_state["last_job_id"] = out["job_id"]
+                except httpx.HTTPStatusError as e:
+                    st.error(_fmt_api_error(e))
+                except httpx.ConnectError as e:
+                    st.error(f"Connection failed: {e}")
+                except Exception as e:
+                    st.exception(e)
+
+        st.subheader("Collections")
+        if st.button("Refresh collections", key="btn_collections"):
+            try:
+                with _client() as c:
+                    r = c.get("/ingest/collections")
+                    r.raise_for_status()
+                    cols = r.json()
+                names = [x["name"] for x in cols.get("collections", [])]
+                st.write(cols.get("message", ""))
+                if names:
+                    st.dataframe({"name": names}, hide_index=True, use_container_width=True)
+                else:
+                    st.info("No collections yet.")
+            except httpx.HTTPStatusError as e:
+                st.error(_fmt_api_error(e))
+            except httpx.ConnectError as e:
+                st.error(f"Connection failed: {e}")
+            except Exception as e:
+                st.exception(e)
+
+        del_name = st.text_input("Delete collection name (optional)", key="del_col")
+        if st.button("Delete collection", key="btn_del_col"):
+            if not del_name.strip():
+                st.warning("Enter a collection name.")
+            else:
+                try:
+                    with _client() as c:
+                        r = c.delete(f"/ingest/collection/{del_name.strip()}")
+                        r.raise_for_status()
+                    st.success(r.json().get("message", "Deleted"))
+                except httpx.HTTPStatusError as e:
+                    st.error(_fmt_api_error(e))
+                except httpx.ConnectError as e:
+                    st.error(f"Connection failed: {e}")
+                except Exception as e:
+                    st.exception(e)
+
+    with tab_jobs:
+        st.subheader("Job list")
+        j1, j2 = st.columns(2)
+        with j1:
+            j_limit = st.number_input("Limit", min_value=1, max_value=100, value=20, key="j_lim")
+        with j2:
+            j_offset = st.number_input("Offset", min_value=0, value=0, key="j_off")
+        if st.button("List jobs", key="btn_jobs"):
+            try:
+                with _client() as c:
+                    r = c.get("/jobs", params={"limit": int(j_limit), "offset": int(j_offset)})
+                    r.raise_for_status()
+                    payload = r.json()
+                jobs: list[dict[str, Any]] = payload.get("jobs", [])
+                st.caption(payload.get("message", ""))
+                if jobs:
+                    st.dataframe(jobs, hide_index=True, use_container_width=True)
+                else:
+                    st.info("No jobs in this window.")
+            except httpx.HTTPStatusError as e:
+                st.error(_fmt_api_error(e))
+            except httpx.ConnectError as e:
+                st.error(f"Connection failed: {e}")
+            except Exception as e:
+                st.exception(e)
+
+        st.subheader("Job detail")
+        default_job = st.session_state.get("last_job_id", "")
+        job_id = st.text_input("Job ID", value=default_job, key="job_id_in")
+        c1, c2 = st.columns(2)
+        with c1:
+            fetch_job = st.button("Fetch job", key="btn_job_one")
+        with c2:
+            poll_job = st.button("Poll until completed/failed", key="btn_job_poll")
+
+        if fetch_job and job_id.strip():
+            try:
+                with _client() as c:
+                    r = c.get(f"/jobs/{job_id.strip()}")
+                    r.raise_for_status()
+                    detail = r.json()
+                st.json(detail)
+            except httpx.HTTPStatusError as e:
+                st.error(_fmt_api_error(e))
+            except httpx.ConnectError as e:
+                st.error(f"Connection failed: {e}")
+            except Exception as e:
+                st.exception(e)
+
+        if poll_job and job_id.strip():
+            status_ph = st.empty()
+            try:
+                with _client() as c:
+                    for i in range(120):
+                        r = c.get(f"/jobs/{job_id.strip()}")
+                        r.raise_for_status()
+                        body = r.json()
+                        job = body.get("job") or {}
+                        st_ = job.get("status", "")
+                        status_ph.write(f"Poll {i + 1}: **{st_}** — {job.get('message', '')}")
+                        if st_ in ("completed", "failed"):
+                            st.json(body)
+                            break
+                        time.sleep(1)
+                    else:
+                        status_ph.write("Stopped after 120 attempts (~2 min).")
+                        st.json(body)
+            except httpx.HTTPStatusError as e:
+                st.error(_fmt_api_error(e))
+            except httpx.ConnectError as e:
+                st.error(f"Connection failed: {e}")
+            except Exception as e:
+                st.exception(e)
+
+    with tab_ask:
+        st.subheader("Ask a question")
+        q_col = st.text_input("Collection", value="default", key="ask_col")
+        question = st.text_area("Question", height=120, key="ask_q")
+        if st.button("Ask", key="btn_ask"):
+            if not question.strip():
+                st.warning("Enter a question.")
+            else:
+                try:
+                    with _client() as c:
+                        r = c.post("/query/ask", json={"question": question.strip(), "collection_name": q_col})
+                        r.raise_for_status()
+                        ans = r.json()
+                    st.success(ans.get("message", ""))
+                    if ans.get("answer"):
+                        st.markdown("### Answer")
+                        st.markdown(ans["answer"])
+                    src = ans.get("sources") or []
+                    if src:
+                        with st.expander(f"Sources ({len(src)})"):
+                            st.json(src)
+                except httpx.HTTPStatusError as e:
+                    st.error(_fmt_api_error(e))
+                except httpx.ConnectError as e:
+                    st.error(f"Connection failed: {e}")
+                except Exception as e:
+                    st.exception(e)
+
+    with tab_sum:
+        st.subheader("Summarise collection")
+        s_col = st.text_input("Collection", value="default", key="sum_col")
+        focus = st.text_input("Optional focus / angle", value="", key="sum_focus")
+        if st.button("Summarise", key="btn_sum"):
+            try:
+                body: dict[str, Any] = {"collection_name": s_col}
+                if focus.strip():
+                    body["focus"] = focus.strip()
+                with _client() as c:
+                    r = c.post("/query/summarise", json=body)
+                    r.raise_for_status()
+                    ans = r.json()
+                st.success(ans.get("message", ""))
+                if ans.get("answer"):
+                    st.markdown("### Summary")
+                    st.markdown(ans["answer"])
+                src = ans.get("sources") or []
+                if src:
+                    with st.expander(f"Sources ({len(src)})"):
+                        st.json(src)
+            except httpx.HTTPStatusError as e:
+                st.error(_fmt_api_error(e))
+            except httpx.ConnectError as e:
+                st.error(f"Connection failed: {e}")
+            except Exception as e:
+                st.exception(e)
+
+    with tab_audit:
+        st.subheader("Audit log")
+        a1, a2 = st.columns(2)
+        with a1:
+            a_limit = st.number_input("Limit", min_value=1, max_value=100, value=20, key="a_lim")
+        with a2:
+            a_offset = st.number_input("Offset", min_value=0, value=0, key="a_off")
+        if st.button("List audit events", key="btn_audit_list"):
+            try:
+                with _client() as c:
+                    r = c.get("/audit/logs", params={"limit": int(a_limit), "offset": int(a_offset)})
+                    r.raise_for_status()
+                    payload = r.json()
+                events = payload.get("events", [])
+                st.caption(payload.get("message", ""))
+                if events:
+                    st.dataframe(events, hide_index=True, use_container_width=True)
+                    ids = [e["event_id"] for e in events if isinstance(e, dict) and "event_id" in e]
+                    if ids:
+                        st.session_state["_audit_ids"] = ids
+                else:
+                    st.info("No audit events.")
+            except httpx.HTTPStatusError as e:
+                st.error(_fmt_api_error(e))
+            except httpx.ConnectError as e:
+                st.error(f"Connection failed: {e}")
+            except Exception as e:
+                st.exception(e)
+
+        st.subheader("Audit event detail")
+        ids_for_select = st.session_state.get("_audit_ids", [])
+        pick = ""
+        if ids_for_select:
+            pick = st.selectbox("Event ID", options=[""] + list(ids_for_select), key="audit_pick")
+        manual_id = st.text_input("Or enter event ID", key="audit_manual")
+        ev_id = (manual_id.strip() or (pick or "").strip()).strip()
+        if st.button("Load detail", key="btn_audit_detail") and ev_id:
+            try:
+                with _client() as c:
+                    r = c.get(f"/audit/logs/{ev_id}")
+                    r.raise_for_status()
+                    st.json(r.json())
+            except httpx.HTTPStatusError as e:
+                st.error(_fmt_api_error(e))
+            except httpx.ConnectError as e:
+                st.error(f"Connection failed: {e}")
+            except Exception as e:
+                st.exception(e)
+
+
+if __name__ == "__main__":
+    main()