Upload 5 files

src/api/__init__.py

@@ -1,4 +1 @@
-from . import admin
-from . import agent
-from . import feedback
-from . import search
+from . import admin, agent, feedback, search

src/api/admin.py

@@ -1,50 +1,99 @@
-from fastapi import APIRouter, HTTPException, Request, Response
-from pydantic import BaseModel
 import secrets
 import time
+from typing import Dict
+
+from fastapi import APIRouter, HTTPException, Request, Response
+from pydantic import BaseModel
+
+from src.config import get_settings
+from src.services.runtime_store import JsonRuntimeStore
 
 router = APIRouter()
+admin_sessions: Dict[str, float] = {}
+
 
 class LoginRequest(BaseModel):
     password: str
 
+
 class ConfigUpdate(BaseModel):
     key: str
     value: str
 
-# Simple session storage (in-memory for HF single instance)
-admin_sessions = {}
+
+def _cleanup_sessions() -> None:
+    now = time.time()
+    expired = [token for token, expiry in admin_sessions.items() if expiry <= now]
+    for token in expired:
+        admin_sessions.pop(token, None)
+
+
+def _config_store() -> JsonRuntimeStore:
+    settings = get_settings()
+    return JsonRuntimeStore(settings.config_path, default={"max_results": settings.max_results, "maintenance_mode": settings.maintenance_mode})
+
 
 @router.post("/auth")
 async def admin_auth(req: LoginRequest):
-    from src.config import get_settings
     settings = get_settings()
-    
-    if req.password != settings.admin_password:
+    if not settings.admin_password or req.password != settings.admin_password:
         raise HTTPException(status_code=401, detail="Invalid password")
-    
     token = secrets.token_hex(32)
-    admin_sessions[token] = time.time() + 86400  # 24 hours
-    
-    resp = Response(content='{"status": "ok"}')
-    resp.set_cookie(key="admin_session", value=token, httponly=True, max_age=86400)
+    admin_sessions[token] = time.time() + 86400
+    resp = Response(content='{"status":"ok"}', media_type="application/json")
+    resp.set_cookie(key="admin_session", value=token, httponly=True, max_age=86400, samesite="lax")
     return resp
 
-@router.get("/config")
-async def get_config():
-    from src.config import get_settings
-    settings = get_settings()
-    return {
-        "max_results": settings.max_results,
-        "maintenance_mode": settings.maintenance_mode
-    }
 
-@router.post("/config")
-async def update_config(req: ConfigUpdate, request: Request):
-    # Verify session
+@router.post("/logout")
+async def admin_logout(request: Request):
+    token = request.cookies.get("admin_session")
+    if token:
+        admin_sessions.pop(token, None)
+    resp = Response(content='{"status":"ok"}', media_type="application/json")
+    resp.delete_cookie("admin_session")
+    return resp
+
+
+def _require_session(request: Request) -> None:
+    _cleanup_sessions()
     token = request.cookies.get("admin_session")
     if not token or token not in admin_sessions:
         raise HTTPException(status_code=401, detail="Not authenticated")
-    
-    # In real implementation, update DB or env
-    return {"status": "ok", "updated": req.key}
+
+
+@router.get("/config")
+async def get_config(request: Request):
+    _require_session(request)
+    return _config_store().load()
+
+
+@router.post("/config")
+async def update_config(req: ConfigUpdate, request: Request):
+    _require_session(request)
+    allowed = {"max_results", "maintenance_mode"}
+    if req.key not in allowed:
+        raise HTTPException(status_code=400, detail=f"Unsupported key. Allowed: {sorted(allowed)}")
+    value = req.value
+    if req.key == "max_results":
+        value = int(value)
+    if req.key == "maintenance_mode":
+        value = str(value).lower() in {"1", "true", "yes", "on"}
+    data = _config_store().load()
+    data[req.key] = value
+    _config_store().save(data)
+    return {"status": "ok", "updated": req.key, "value": value}
+
+
+@router.get("/rag-status")
+async def rag_status(request: Request):
+    _require_session(request)
+    from app import rag_service
+    return rag_service.get_stats()
+
+
+@router.get("/metrics")
+async def metrics(request: Request):
+    _require_session(request)
+    from app import metrics_service
+    return metrics_service.snapshot()

src/api/agent.py

@@ -17,6 +17,7 @@ from src.services.staff_service import (
     STAFF_DIRECTORY,
     match_staff_name,
     match_staff_role,
+    should_attempt_staff_lookup,
     staff_name_answer,
     staff_role_answer,
 )
@@ -258,6 +259,23 @@ def _source_badge(source: str, url: str = "") -> str:
     )
 
 
+
+
+def _safe_metrics_increment(key: str) -> None:
+    try:
+        from app import metrics_service
+        metrics_service.incr(key)
+    except Exception:
+        return
+
+
+def _safe_metrics_bucket(bucket: str, key: str) -> None:
+    try:
+        from app import metrics_service
+        metrics_service.incr_bucket(bucket, key)
+    except Exception:
+        return
+
 def _build_history_messages(history: List[ChatMessage]) -> List[dict]:
     msgs = []
     for m in history[-HISTORY_WINDOW:]:
@@ -1054,6 +1072,7 @@ async def _research_snapshot(context: SearchContextPayload, model: str) -> Tuple
     if papers:
         summary = await _generate_cited_summary(topic, papers, model)
         if not summary:
+            _safe_metrics_increment("summary_fallbacks")
             summary = _extractive_snapshot_from_papers(topic, papers)
 
         answer = f"<strong>📖 Research Snapshot: {_escape(topic)}</strong><br><br>{summary}"
@@ -1078,7 +1097,7 @@ async def _research_snapshot(context: SearchContextPayload, model: str) -> Tuple
     if search_results:
         answer = (
             f"<strong>📚 KU Library starting points on {_escape(topic)}</strong><br><br>"
-            "I couldn't build a citation-grounded abstract snapshot right now, but I did pull KU-accessible results you can open immediately below. "
+            "I couldn't build a citation-grounded Semantic Scholar snapshot right now, but I did pull KU-accessible library results you can open immediately below. "
             f"<br><br><strong>AI sources:</strong> {_database_guidance_for_topic(context)}"
         )
     else:
@@ -1237,6 +1256,7 @@ async def agent_query(request: Request, req: AgentRequest):
     history = req.history
     model = req.model
     client_state = req.client_state
+    _safe_metrics_increment("agent_requests")
 
     if not question:
         follow_up_question, follow_up_suggestions = _social_follow_up()
@@ -1265,8 +1285,9 @@ async def agent_query(request: Request, req: AgentRequest):
             follow_up_suggestions=follow_up_suggestions,
         )
 
-    staff_match = match_staff_name(question)
+    staff_match = match_staff_name(question) if should_attempt_staff_lookup(question) else None
     if staff_match:
+        _safe_metrics_bucket("intents", "staff_lookup")
         follow_up_question, follow_up_suggestions = _library_follow_up(question)
         return AgentResponse(
             answer=staff_name_answer(staff_match) + _source_badge("ku_library", "https://library.ku.ac.ae/"),
@@ -1278,8 +1299,9 @@ async def agent_query(request: Request, req: AgentRequest):
             follow_up_suggestions=follow_up_suggestions,
         )
 
-    staff_role_match = match_staff_role(question)
+    staff_role_match = match_staff_role(question) if should_attempt_staff_lookup(question) else None
     if staff_role_match:
+        _safe_metrics_bucket("intents", "staff_lookup")
         follow_up_question, follow_up_suggestions = _library_follow_up(question)
         return AgentResponse(
             answer=staff_role_answer(staff_role_match, question) + _source_badge("ku_library", "https://library.ku.ac.ae/"),
@@ -1332,6 +1354,7 @@ async def agent_query(request: Request, req: AgentRequest):
     is_follow_up, follow_up_action, base_context = _detect_follow_up(question, client_state)
 
     if is_follow_up and base_context:
+        _safe_metrics_increment("follow_up_hits")
         context = _apply_follow_up_action(base_context, follow_up_action)
         if follow_up_action in {"summarize_topic", "deep_research_tools", "best_databases"}:
             context = await _prepare_queries(question, context, model, True)
@@ -1347,6 +1370,7 @@ async def agent_query(request: Request, req: AgentRequest):
                 search_results = []
                 sources = []
             follow_up_question, follow_up_suggestions = _search_follow_up(context, summary_mode=True)
+            _safe_metrics_increment("search_handoffs")
             return AgentResponse(
                 answer=answer,
                 intent=context.intent,
@@ -1391,6 +1415,7 @@ async def agent_query(request: Request, req: AgentRequest):
 
     cls_result = await _llm_classify(question, history, model)
     intent = cls_result.get("intent", "general")
+    _safe_metrics_bucket("intents", intent)
     casual_hint = cls_result.get("casual_answer", "")
 
     if intent == "social":
@@ -1469,6 +1494,7 @@ async def agent_query(request: Request, req: AgentRequest):
             if deep_research_mode and "Research guide" not in answer:
                 answer += f"<br><br><strong>Research guide:</strong> {_database_guidance_for_topic(context)}"
             follow_up_question, follow_up_suggestions = _search_follow_up(context, summary_mode=True)
+            _safe_metrics_increment("search_handoffs")
             return AgentResponse(
                 answer=answer,
                 intent=intent,

src/api/feedback.py

@@ -1,8 +1,12 @@
+import json
 import time
-from typing import List
+from pathlib import Path
+from typing import Optional
 
 from fastapi import APIRouter
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
+
+from src.config import get_settings
 
 router = APIRouter()
 
@@ -10,22 +14,32 @@ router = APIRouter()
 class FeedbackRequest(BaseModel):
     question: str
     feedback: str
-    answer_excerpt: str = ""
-
+    answer_excerpt: Optional[str] = ""
 
-_FEEDBACK_LOG: List[dict] = []
+    @field_validator("feedback")
+    @classmethod
+    def valid_feedback(cls, v: str) -> str:
+        if v not in {"up", "down"}:
+            raise ValueError("feedback must be up or down")
+        return v
 
 
 @router.post("")
-async def store_feedback(req: FeedbackRequest):
-    _FEEDBACK_LOG.append(
-        {
-            "question": req.question[:500],
-            "feedback": req.feedback[:20],
-            "answer_excerpt": req.answer_excerpt[:1000],
-            "timestamp": time.time(),
-        }
-    )
-    if len(_FEEDBACK_LOG) > 1000:
-        del _FEEDBACK_LOG[:-1000]
+async def save_feedback(req: FeedbackRequest):
+    settings = get_settings()
+    payload = {
+        "timestamp": time.time(),
+        "question": req.question[:1000],
+        "feedback": req.feedback,
+        "answer_excerpt": (req.answer_excerpt or "")[:1500],
+    }
+    settings.feedback_path.parent.mkdir(parents=True, exist_ok=True)
+    with settings.feedback_path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+    try:
+        from app import metrics_service
+        metrics_service.incr("feedback_total")
+        metrics_service.incr_bucket("feedback_breakdown", req.feedback)
+    except Exception:
+        pass
     return {"status": "ok"}

src/api/search.py

@@ -3,7 +3,7 @@ from typing import Optional
 from urllib.parse import quote
 
 import httpx
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter
 from pydantic import BaseModel, field_validator
 
 from src.config import get_settings
@@ -12,8 +12,6 @@ logger = logging.getLogger(__name__)
 router = APIRouter()
 
 
-# ── Request Model ──────────────────────────────────────────────────────────────
-
 class SearchRequest(BaseModel):
     query: str
     source: str = "primo"
@@ -49,140 +47,106 @@ class SearchRequest(BaseModel):
         return v
 
 
-# ── Main Endpoint ──────────────────────────────────────────────────────────────
+def _safe_metrics_increment(key: str) -> None:
+    try:
+        from app import metrics_service
+        metrics_service.incr(key)
+    except Exception:
+        return
+
+
+def _safe_metrics_bucket(bucket: str, key: str) -> None:
+    try:
+        from app import metrics_service
+        metrics_service.incr_bucket(bucket, key)
+    except Exception:
+        return
+
 
 @router.post("")
 async def search_endpoint(req: SearchRequest):
+    _safe_metrics_increment("search_requests")
+    _safe_metrics_bucket("search_sources", req.source)
     settings = get_settings()
-
     if req.source == "primo":
         return await search_primo(req, settings.primo_api_key)
-    elif req.source == "pubmed":
+    if req.source == "pubmed":
         return await search_pubmed(req)
-    elif req.source == "scholar":
-        return await search_scholar(req)
+    return await search_scholar(req)
 
 
-# ── Primo ──────────────────────────────────────────────────────────────────────
-
 async def search_primo(req: SearchRequest, api_key: str):
     if not api_key:
         logger.warning("PRIMO_API_KEY not configured")
+        _safe_metrics_bucket("errors", "primo_missing_api_key")
         return {"error": "PRIMO_API_KEY not configured", "results": [], "source": "PRIMO"}
 
     query_encoded = quote(req.query)
-
-    # NOTE: Ex Libris Primo API requires apikey as a URL query parameter.
-    # The Authorization header approach does NOT work with this API.
     url = (
         f"https://api-eu.hosted.exlibrisgroup.com/primo/v1/search"
-        f"?vid=971KUOSTAR_INST:KU"
-        f"&tab=Everything"
-        f"&scope=MyInst_and_CI"
-        f"&q=any,contains,{query_encoded}"
-        f"&lang=en"
-        f"&sort=rank"
-        f"&limit={req.limit}"
-        f"&offset=0"
-        f"&mode=advanced"
-        f"&apikey={api_key}"
+        f"?vid=971KUOSTAR_INST:KU&tab=Everything&scope=MyInst_and_CI"
+        f"&q=any,contains,{query_encoded}&lang=en&sort=rank&limit={req.limit}"
+        f"&offset=0&mode=advanced&apikey={api_key}"
     )
-
-    # Build facets for peer reviewed / open access / year filters
     facets = []
     if req.peer_reviewed:
         facets.append("facet_tlevel,include,peer_reviewed")
     if req.open_access:
         facets.append("facet_tlevel,include,open_access")
     if req.year_from or req.year_to:
-        yf = req.year_from or "0001"
-        yt = req.year_to or "9999"
-        facets.append(f"facet_searchcreationdate,include,{yf}|,|{yt}")
-
+        facets.append(f"facet_searchcreationdate,include,{req.year_from or '0001'}|,|{req.year_to or '9999'}")
     for facet in facets:
         url += f"&multiFacets={quote(facet)}"
 
     try:
         async with httpx.AsyncClient(timeout=20) as client:
             r = await client.get(url, headers={"Accept": "application/json"})
-
-            logger.info(f"Primo API status: {r.status_code} for query: {req.query[:50]}")
-
-            if r.status_code == 401:
-                logger.error("Primo API: 401 Unauthorized — check PRIMO_API_KEY")
-                return {"error": "PRIMO API authentication failed — check API key", "results": [], "source": "PRIMO"}
-
-            if r.status_code == 400:
-                logger.error(f"Primo API: 400 Bad Request — {r.text[:200]}")
-                return {"error": "PRIMO API bad request — query may be malformed", "results": [], "source": "PRIMO"}
-
+            logger.info("Primo status=%s query=%s", r.status_code, req.query[:60])
             if r.status_code != 200:
-                logger.warning(f"Primo API returned {r.status_code}: {r.text[:200]}")
+                _safe_metrics_bucket("errors", f"primo_{r.status_code}")
                 return {"error": f"PRIMO API error: {r.status_code}", "results": [], "source": "PRIMO"}
-
             data = r.json()
             docs = data.get("docs", [])
-            logger.info(f"Primo returned {len(docs)} docs, total={data.get('info', {}).get('total', 0)}")
-
             results = []
-            for doc in docs[:req.limit]:
+            for doc in docs[: req.limit]:
                 pnx = doc.get("pnx", {})
                 d = pnx.get("display", {})
-
                 results.append({
                     "title": (d.get("title") or ["Untitled"])[0],
                     "creator": "; ".join(d.get("creator") or d.get("contributor") or []) or "Unknown",
                     "date": (d.get("date") or [""])[0],
                     "type": (d.get("type") or [""])[0],
                     "source": (d.get("source") or [""])[0],
-                    "primo_url": (
-                        f"https://khalifa.primo.exlibrisgroup.com/discovery/search"
-                        f"?query=any,contains,{query_encoded}&vid=971KUOSTAR_INST:KU"
-                    ),
+                    "primo_url": f"https://khalifa.primo.exlibrisgroup.com/discovery/search?query=any,contains,{query_encoded}&vid=971KUOSTAR_INST:KU",
                     "_source": "PRIMO",
                 })
-
-            return {
-                "total": data.get("info", {}).get("total", 0),
-                "results": results,
-                "source": "PRIMO",
-            }
-
+            return {"total": data.get("info", {}).get("total", 0), "results": results, "source": "PRIMO"}
     except httpx.TimeoutException:
-        logger.error("Primo API timed out")
+        _safe_metrics_bucket("errors", "primo_timeout")
         return {"error": "PRIMO API timed out — please try again", "results": [], "source": "PRIMO"}
-    except Exception as e:
-        logger.error(f"Primo search error: {e}", exc_info=True)
-        return {"error": str(e), "results": [], "source": "PRIMO"}
+    except Exception as exc:
+        logger.error("Primo search error: %s", exc, exc_info=True)
+        _safe_metrics_bucket("errors", "primo_exception")
+        return {"error": str(exc), "results": [], "source": "PRIMO"}
 
 
-# ── PubMed ─────────────────────────────────────────────────────────────────────
-
 async def search_pubmed(req: SearchRequest):
     query_encoded = quote(req.query)
-
     try:
         async with httpx.AsyncClient(timeout=15) as client:
-            search_url = (
-                f"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
-                f"?db=pubmed&term={query_encoded}&retmax={req.limit}&retmode=json"
-            )
+            search_url = f"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term={query_encoded}&retmax={req.limit}&retmode=json"
             r = await client.get(search_url)
             if r.status_code != 200:
+                _safe_metrics_bucket("errors", "pubmed_search_failed")
                 return {"error": "PubMed search failed", "results": [], "source": "PubMed"}
-
             ids = r.json().get("esearchresult", {}).get("idlist", [])
             if not ids:
                 return {"total": 0, "results": [], "source": "PubMed"}
-
-            fetch_url = (
-                f"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi"
-                f"?db=pubmed&id={','.join(ids)}&retmode=json"
-            )
+            fetch_url = f"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id={','.join(ids)}&retmode=json"
             r2 = await client.get(fetch_url)
             if r2.status_code != 200:
+                _safe_metrics_bucket("errors", "pubmed_fetch_failed")
                 return {"error": "PubMed fetch failed", "results": [], "source": "PubMed"}
-
             data = r2.json().get("result", {})
             results = []
             for pid in ids:
@@ -193,7 +157,6 @@ async def search_pubmed(req: SearchRequest):
                 authors = ", ".join(a.get("name", "") for a in author_list[:3])
                 if len(author_list) > 3:
                     authors += " et al."
-
                 results.append({
                     "title": rec.get("title", ""),
                     "creator": authors,
@@ -204,32 +167,21 @@ async def search_pubmed(req: SearchRequest):
                     "type": "Journal Article",
                     "_source": "PubMed",
                 })
-
             return {"total": len(ids), "results": results, "source": "PubMed"}
-
-    except Exception as e:
-        logger.error(f"PubMed search error: {e}")
-        return {"error": str(e), "results": [], "source": "PubMed"}
+    except Exception as exc:
+        logger.error("PubMed search error: %s", exc)
+        _safe_metrics_bucket("errors", "pubmed_exception")
+        return {"error": str(exc), "results": [], "source": "PubMed"}
 
 
-# ── Semantic Scholar ───────────────────────────────────────────────────────────
-
 async def search_scholar(req: SearchRequest):
     try:
-        params = {
-            "query": req.query,
-            "limit": req.limit,
-            "fields": "title,authors,year,venue,externalIds,citationCount",
-        }
-
+        params = {"query": req.query, "limit": req.limit, "fields": "title,authors,year,venue,externalIds,citationCount"}
         async with httpx.AsyncClient(timeout=15) as client:
-            r = await client.get(
-                "https://api.semanticscholar.org/graph/v1/paper/search",
-                params=params,
-            )
+            r = await client.get("https://api.semanticscholar.org/graph/v1/paper/search", params=params)
             if r.status_code != 200:
+                _safe_metrics_bucket("errors", f"semantic_{r.status_code}")
                 return {"error": f"Semantic Scholar API: {r.status_code}", "results": [], "source": "Semantic Scholar"}
-
             data = r.json()
             results = []
             for paper in data.get("data", []):
@@ -237,7 +189,6 @@ async def search_scholar(req: SearchRequest):
                 authors = ", ".join(a.get("name", "") for a in author_list[:3])
                 if len(author_list) > 3:
                     authors += " et al."
-
                 paper_id = paper.get("paperId")
                 results.append({
                     "title": paper.get("title", ""),
@@ -249,13 +200,8 @@ async def search_scholar(req: SearchRequest):
                     "type": "Article",
                     "_source": "Semantic Scholar",
                 })
-
-            return {
-                "total": data.get("total", 0),
-                "results": results,
-                "source": "Semantic Scholar",
-            }
-
-    except Exception as e:
-        logger.error(f"Semantic Scholar search error: {e}")
-        return {"error": str(e), "results": [], "source": "Semantic Scholar"}
+            return {"total": data.get("total", 0), "results": results, "source": "Semantic Scholar"}
+    except Exception as exc:
+        logger.error("Semantic Scholar search error: %s", exc)
+        _safe_metrics_bucket("errors", "semantic_exception")
+        return {"error": str(exc), "results": [], "source": "Semantic Scholar"}