Upload 3 files

Dockerfile

@@ -1,7 +1,11 @@
-FROM python:3.11-slim
+FROM python:3.9-slim
+
 WORKDIR /app
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
+
 COPY . .
-EXPOSE 7860
+
+# HF Spaces requires port 7860
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,448 +1,255 @@
 """
-Research Navigator — FastAPI backend for HuggingFace Spaces
-Endpoints: /api/analyze-journal, /api/check-license, /api/find-repository, /api/health
+app.py — LibBee v3.5
+FastAPI entry point: CORS, middleware, lifespan, router mounting.
+
+Changes over v3.1:
+- Maintenance mode middleware now reads from JsonRuntimeStore (admin-editable)
+  instead of settings.maintenance_mode (env var, static at startup).
+- CORS origins updated: added ku-library.github.io.
+- Section headers added throughout.
 """
-import os, json, re, asyncio
-from fastapi import FastAPI, HTTPException
+
+# ── Imports ────────────────────────────────────────────────────────────────────
+
+import asyncio
+import logging
+import time
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse, Response
-from pydantic import BaseModel
-from typing import Optional
-from openai import AsyncOpenAI
+from fastapi.responses import JSONResponse
+
+try:
+    from cachetools import TTLCache
+    _ttl_cache_available = True
+except ImportError:
+    _ttl_cache_available = False
+
+from src.config import get_settings
+from src.services.cache_service import CacheService
+from src.services.metrics_service import MetricsService
+from src.services.rag_service import RAGService
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ── Service Instances ──────────────────────────────────────────────────────────
+
+rag_service     = RAGService()
+cache_service   = CacheService()
+metrics_service = MetricsService(get_settings().metrics_path)
+
+
+# ── Rate-limit Request Log ─────────────────────────────────────────────────────
+# TTLCache auto-evicts entries older than ttl seconds.
+# Falls back to a plain deque-based dict if cachetools is not installed.
+
+if _ttl_cache_available:
+    _request_log      = TTLCache(maxsize=10_000, ttl=120)
+    _request_log_lock = asyncio.Lock()
+else:
+    from collections import defaultdict, deque
+    _request_log      = defaultdict(deque)   # type: ignore[assignment]
+    _request_log_lock = asyncio.Lock()
+
+
+# ── Public Accessors ───────────────────────────────────────────────────────────
+# Routers import these instead of importing module-level globals directly,
+# which avoids circular-import issues at import time.
+
+def get_rag_service() -> RAGService:
+    return rag_service
+
+
+def get_metrics_service() -> MetricsService:
+    return metrics_service
+
+
+# ── Background Tasks ───────────────────────────────────────────────────────────
+
+async def _metrics_flush_loop(interval: int = 30) -> None:
+    """Flush in-memory metric counters to disk every `interval` seconds."""
+    while True:
+        await asyncio.sleep(interval)
+        try:
+            await metrics_service.flush()
+        except Exception as exc:
+            logger.warning("Metrics flush error: %s", exc)
+
+
+# ── Lifespan ───────────────────────────────────────────────────────────────────
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    from src.services.staff_service import build_staff_index
+
+    settings = get_settings()
+
+    # Build staff index
+    try:
+        build_staff_index()
+        logger.info("Staff index built")
+    except Exception as exc:
+        logger.error("Staff index build failed: %s", exc)
+
+    # Initialise RAG service
+    if settings.openai_api_key:
+        try:
+            await rag_service.initialize(openai_api_key=settings.openai_api_key)
+            logger.info("RAG service ready — chunks: %d", len(rag_service.bm25_corpus))
+        except Exception as exc:
+            logger.error("RAG initialization failed: %s", exc, exc_info=True)
+    else:
+        logger.warning("OPENAI_API_KEY not set — RAG disabled")
 
-from scimago_index import lookup_any, load_scimago, search_by_subject, load_subject_index
-from openalex import enrich_all
-from prompts import JOURNAL_SYSTEM_PROMPT, LICENSE_SYSTEM_PROMPT, REPO_SYSTEM_PROMPT, SUBJECT_NORMALISE_PROMPT
+    # Start background metrics flush
+    flush_task = asyncio.create_task(_metrics_flush_loop(interval=30))
+    logger.info("LibBee startup complete")
 
-# ── App setup ────────��─────────────────────────────────────────────────────
-app = FastAPI(title="Research Navigator API", version="1.0.0")
+    yield
+
+    # Graceful shutdown — flush remaining metrics
+    flush_task.cancel()
+    try:
+        await asyncio.wait_for(metrics_service.flush(), timeout=5.0)
+    except Exception:
+        pass
+    logger.info("LibBee shutting down")
+
+
+# ── FastAPI App ────────────────────────────────────────────────────────────────
+
+app = FastAPI(
+    title="LibBee - KU Library AI",
+    description="Khalifa University Library AI Assistant",
+    version="3.5.0",
+    lifespan=lifespan,
+)
+
+
+# ── CORS Middleware ────────────────────────────────────────────────────────────
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
+    allow_origins=[
+        "https://nikeshn.github.io",
+        "https://ku-library.github.io",       # added v3.5
+        "http://localhost:8080",
+        "http://localhost:3000",
+        "http://127.0.0.1:5500",
+    ],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
     allow_headers=["*"],
+    max_age=86400,
 )
 
-# Preload SCImago at startup
-@app.on_event("startup")
-async def startup():
-    load_scimago()
-    load_subject_index()
-
-# ── OpenAI client ──────────────────────────────────────────────────────────
-def get_client():
-    key = os.environ.get("OPENAI_API_KEY")
-    if not key:
-        raise HTTPException(500, "OPENAI_API_KEY not configured")
-    return AsyncOpenAI(api_key=key)
-
-# ── Constants ──────────────────────────────────────────────────────────────
-KHAZNA = {
-    "name": "Khazna — Khalifa University Research Portal",
-    "type": "Institutional",
-    "url": "https://khazna.ku.ac.ae",
-    "scope": "Khalifa University institutional repository for articles, theses, datasets and research output.",
-    "fit_reason": "Primary institutional repository for all KU researchers. Deposit here for KU compliance and visibility.",
-    "data_types_accepted": "All types — articles, datasets, theses, preprints, reports",
-    "max_file_size": "Contact library for large datasets",
-    "licences_supported": "CC BY, CC BY-NC, CC BY-NC-ND, Restricted",
-    "persistent_identifier": "Handle",
-    "versioning": "Yes",
-    "embargo_support": "Yes",
-    "access_model": "Mixed",
-    "cost": "Free",
-    "certification": "Institutional",
-    "fair_alignment": "High",
-    "funder_compliance_note": "Satisfies KU institutional OA and RDM policy requirements.",
-    "sensitive_data_suitable": "Conditional",
-    "confidence": "High",
-    "verification_status": "Confirmed — KU institutional repository",
-    "risk_flag": None,
-    "is_khazna": True,
-    "verify_links": {
-        "re3data": "https://www.re3data.org/search?query=Khalifa+University",
-        "fairsharing": "https://fairsharing.org/search?q=Khalifa+University",
-        "khazna_contact": "mailto:khazna@ku.ac.ae"
-    }
-}
-
-KHAZNA_DEPOSIT_CARD = {
-    "title": "🏛️ Deposit to Khazna — KU Institutional Repository",
-    "url": "https://khazna.ku.ac.ae",
-    "contact": "khazna@ku.ac.ae",
-    "library_url": "https://library.ku.ac.ae/lib",
-    "message": "As a KU researcher, deposit your accepted manuscript (or metadata record if under embargo) to Khazna for institutional visibility and compliance.",
-    "metadata_tip": "Even if depositing data in a domain-specific repository, always register metadata in Khazna so your work appears in KU's research portfolio."
-}
-
-def _norm_issn(raw):
-    if not raw: return None
-    d = str(raw).strip().upper().replace(" ","").replace("-","")
-    if len(d) == 8: return f"{d[:4]}-{d[4:]}"
-    return None
-
-def build_verify_links(name: str, issn: Optional[str]) -> dict:
-    q = re.sub(r'[^\w\s]', '', name)
-    ni = _norm_issn(issn)
-    iq = ni or q
+
+# ── Operational Guardrails Middleware ──────────────────────────────────────────
+
+@app.middleware("http")
+async def operational_guardrails(request: Request, call_next):
+    settings = get_settings()
+
+    # ── Maintenance mode ───────────────────────────────────────────────────────
+    # FIX v3.5: read from JsonRuntimeStore (admin-editable) rather than
+    # settings.maintenance_mode (env var, static at startup). This means
+    # toggling maintenance via the admin dashboard actually takes effect.
+    _maintenance_on = False
+    try:
+        from src.services.runtime_store import JsonRuntimeStore
+        _store = JsonRuntimeStore(settings.config_path, default={"maintenance_mode": False})
+        _maintenance_on = bool(_store.load().get("maintenance_mode", False))
+    except Exception:
+        # If store is unreadable fall back to env-var setting
+        _maintenance_on = settings.maintenance_mode
+
+    _exempt_paths = {"/", "/config", "/admin", "/admin/login", "/admin/auth"}
+    if _maintenance_on and request.url.path not in _exempt_paths:
+        return JSONResponse(
+            status_code=503,
+            content={"detail": "LibBee is in maintenance mode. Please try again shortly."},
+        )
+
+    # ── Rate limiting ──────────────────────────────────────────────────────────
+    client_ip = request.client.host if request.client else "unknown"
+    now = time.time()
+
+    async with _request_log_lock:
+        if _ttl_cache_available:
+            timestamps = _request_log.get(client_ip, [])
+            timestamps = [t for t in timestamps if now - t < 60]
+            if len(timestamps) >= settings.rate_limit_per_minute:
+                metrics_service.incr_bucket("errors", "rate_limit")
+                return JSONResponse(
+                    status_code=429,
+                    content={"detail": "Too many requests. Please slow down and try again."},
+                )
+            timestamps.append(now)
+            _request_log[client_ip] = timestamps
+        else:
+            from collections import deque
+            bucket = _request_log[client_ip]  # type: ignore[index]
+            while bucket and now - bucket[0] > 60:
+                bucket.popleft()
+            if len(bucket) >= settings.rate_limit_per_minute:
+                metrics_service.incr_bucket("errors", "rate_limit")
+                return JSONResponse(
+                    status_code=429,
+                    content={"detail": "Too many requests. Please slow down and try again."},
+                )
+            bucket.append(now)
+
+    # ── Request execution ──────────────────────────────────────────────────────
+    try:
+        response = await call_next(request)
+        return response
+    except Exception as exc:
+        logger.exception("Unhandled application error: %s", exc)
+        metrics_service.incr_bucket("errors", "unhandled_exception")
+        return JSONResponse(status_code=500, content={"detail": "Unexpected server error."})
+
+
+# ── Router Mounting ────────────────────────────────────────────────────────────
+
+from src.api import admin, agent, feedback, search  # noqa: E402
+
+app.include_router(agent.router,    prefix="/agent",    tags=["Agent"])
+app.include_router(search.router,   prefix="/search",   tags=["Search"])
+app.include_router(admin.router,    prefix="/admin",    tags=["Admin"])
+app.include_router(feedback.router, prefix="/feedback", tags=["Feedback"])
+
+
+# ── Health & Public Endpoints ──────────────────────────────────────────────────
+
+@app.get("/")
+def health_check():
+    settings = get_settings()
     return {
-        "sherpa_romeo": f"https://openpolicyfinder.jisc.ac.uk/search?query={iq}",
-        "scopus":       f"https://www.scopus.com/sources?search={iq}",
-        "scimago":      f"https://www.scimagojr.com/journalsearch.php?q={iq}&tip={'iss' if ni else 'jou'}",
-        "doaj":         f"https://doaj.org/toc/{ni}" if ni else f"https://doaj.org/search/journals?source=%7B%22query%22%3A%7B%22query_string%22%3A%7B%22query%22%3A%22{q}%22%7D%7D%7D",
-        "openalex":     f"https://api.openalex.org/sources/issn:{ni}" if ni else f"https://api.openalex.org/sources?search={q}",
+        "status": "ok",
+        "version": "3.5.0",
+        "service": "LibBee KU Library AI",
+        "rag_ready": rag_service.is_ready(),
+        "maintenance_mode": settings.maintenance_mode,
+        "endpoints": ["/agent", "/search", "/admin", "/feedback"],
     }
 
-def enrich_ranking(journal: dict, scimago: Optional[dict], oa_pct: Optional[dict]) -> dict:
-    """Build ranking block from SCImago (private) + OpenAlex percentile."""
-    if scimago:
-        q = scimago.get("quartile", "")
-        return {
-            "requested": True,
-            "source": "Verified from journal data",
-            "year": "2025",
-            "category": scimago.get("categories", ""),
-            "metric_value": None,  # Never expose SJR value
-            "percentile": f"Rank #{scimago.get('rank','—')} globally" if scimago.get("rank") else None,
-            "quartile": q if q and q != "-" else None,
-            "interpretation": f"Quartile verified from journal metadata (2025 dataset, matched by ISSN {scimago.get('matched_issn','')}).",
-            "verification_status": "Confirmed",
-            "h_index": scimago.get("h_index"),
-        }
-    elif oa_pct:
-        return {
-            "requested": True,
-            "source": "OpenAlex-derived percentile",
-            "year": "2025",
-            "category": oa_pct.get("concept"),
-            "metric_value": None,
-            "percentile": f"{oa_pct['percentile']}th percentile within {oa_pct['peer_count']} {oa_pct['concept']} journals",
-            "quartile": oa_pct.get("quartile"),
-            "interpretation": f"OpenAlex-derived percentile — NOT a Scopus/SCImago quartile. Computed from 2-year mean citedness vs peer journals in the same concept field.",
-            "verification_status": "OpenAlex-derived (not a Scopus/SCImago metric)",
-        }
-    else:
-        return {
-            "requested": True,
-            "source": "Not available",
-            "year": None, "category": None, "metric_value": None,
-            "percentile": None, "quartile": None,
-            "interpretation": "No journal metrics match found. Use verify links to check Scopus Sources directly.",
-            "verification_status": "Not confirmed — verify manually via Scopus Sources link",
-        }
-
-async def enrich_journals(journals: list) -> list:
-    """Add SCImago quartile, OpenAlex metrics, ranking, verify links to each journal."""
-    enriched_oa = await enrich_all(journals)
-    result = []
-    for j in enriched_oa:
-        issn = j.get("issn")
-        oa = j.get("openalex") or {}
-        all_issns = [issn, oa.get("issn_l")] + (oa.get("issns") or [])
-        scimago = lookup_any(all_issns)
-        oa_pct = j.get("oa_percentile")
-        # Final ISSN: prefer scimago matched, then openalex issn_l, then original
-        final_issn = (scimago or {}).get("matched_issn") or oa.get("issn_l") or issn
-        j["issn"] = final_issn
-        j["ranking"] = enrich_ranking(j, scimago, oa_pct)
-        j["verify_links"] = build_verify_links(j.get("name",""), final_issn)
-        # Clean up internal fields
-        j.pop("oa_percentile", None)
-        result.append(j)
-    return result
-
-def enrich_extended(extended: list) -> list:
-    """Add verify links + SCImago quartile to extended list items."""
-    index_result = []
-    for j in extended:
-        issn = j.get("issn")
-        scimago = lookup_any([issn]) if issn else None
-        q = (scimago or {}).get("quartile", "")
-        j["quartile"] = q if q and q != "-" else None
-        j["verify_links"] = build_verify_links(j.get("name",""), issn)
-        index_result.append(j)
-    return index_result
-
-async def call_openai(client, model: str, system: str, user: str) -> dict:
-    resp = await client.chat.completions.create(
-        model=model,
-        response_format={"type": "json_object"},
-        messages=[
-            {"role": "system", "content": system},
-            {"role": "user",   "content": user}
-        ],
-        max_tokens=4096,
-        temperature=0.3,
-    )
-    content = resp.choices[0].message.content or "{}"
-    try:
-        return json.loads(content)
-    except json.JSONDecodeError:
-        m = re.search(r'\{[\s\S]*\}', content)
-        return json.loads(m.group(0)) if m else {"error": "Failed to parse response"}
-
-# ── Request models ─────────────────────────────────────────────────────────
-class ManuscriptInput(BaseModel):
-    title: str
-    abstract: str
-    keywords: str = ""
-    discipline: str = ""
-    article_type: str = "Original research article"
-    methods: str = ""
-    audience: str = ""
-    funder: str = ""
-    institution: str = ""
-    country: str = ""
-    apc_budget: str = ""
-    oa_preference: str = "Either"
-    ranking_preference: str = "No filter"
-    ranking_source: str = "Either"
-    speed_preference: str = "Standard"
-    preferred_journals: str = ""
-    avoid_journals: str = ""
-    repository_target: str = "Institutional repository"
-
-class JournalRequest(BaseModel):
-    manuscript: ManuscriptInput
-    model: str = "gpt-4o-mini"
-
-class LicenseInput(BaseModel):
-    journal_name: str
-    issn: str = ""
-    publisher: str = ""
-    manuscript_version: str = "All versions"
-    funder: str = ""
-    intended_repository: str = "Institutional repository"
-    intended_licence: str = "CC BY"
-    notes: str = ""
-
-class LicenseRequest(BaseModel):
-    license_input: LicenseInput
-    model: str = "gpt-4o-mini"
-
-class DatasetInput(BaseModel):
-    title: str
-    description: str
-    discipline: str
-    data_types: str
-    file_formats: str = ""
-    approx_size: str = ""
-    sensitivity: str = "Open"
-    contains_personal_data: str = "No"
-    licence_intent: str = "CC BY"
-    funder: str = ""
-    institution: str = ""
-    country: str = ""
-    needs_doi: str = "Yes"
-    needs_versioning: str = "Yes"
-    embargo_required: str = "No"
-    preferred_repository: str = ""
-    related_publication: str = ""
-    notes: str = ""
-
-class RepoRequest(BaseModel):
-    dataset: DatasetInput
-    model: str = "gpt-4o-mini"
-
-# ── Routes ─────────────────────────────────────────────────────────────────
-@app.get("/api/health")
-async def health():
-    return {"status": "ok", "service": "Research Navigator"}
-
-@app.post("/api/analyze-journal")
-async def analyze_journal(req: JournalRequest):
-    model = req.model if req.model in ("gpt-4o-mini", "gpt-4o") else "gpt-4o-mini"
-    client = get_client()
-    user_msg = f"""Analyse this manuscript and return the structured JSON response.
-
-MANUSCRIPT INPUT:
-{json.dumps(req.manuscript.dict(), indent=2)}
-
-Return JSON only — no prose outside the JSON object."""
-
-    parsed = await call_openai(client, model, JOURNAL_SYSTEM_PROMPT, user_msg)
-    if "error" in parsed:
-        raise HTTPException(500, parsed["error"])
-
-    # Enrich detailed journals
-    if isinstance(parsed.get("journals"), list):
-        parsed["journals"] = await enrich_journals(parsed["journals"])
-
-    # Enrich extended list (lightweight — just quartile + verify links)
-    if isinstance(parsed.get("extended_list"), list):
-        parsed["extended_list"] = enrich_extended(parsed["extended_list"])
-
-    # Always inject Khazna deposit card
-    parsed["khazna"] = KHAZNA_DEPOSIT_CARD
-
-    return {"result": parsed}
-
-@app.post("/api/check-license")
-async def check_license(req: LicenseRequest):
-    model = req.model if req.model in ("gpt-4o-mini", "gpt-4o") else "gpt-4o-mini"
-    client = get_client()
-    li = req.license_input
-    user_msg = f"""Check the Green OA / self-archiving policy for this journal. Return JSON only.
-
-JOURNAL DETAILS:
-- Journal name: {li.journal_name}
-- ISSN: {li.issn or 'Not provided'}
-- Publisher: {li.publisher or 'Not provided'}
-- Manuscript version of interest: {li.manuscript_version}
-- Funder: {li.funder or 'None'}
-- Intended repository: {li.intended_repository}
-- Intended licence: {li.intended_licence}
-- Additional notes: {li.notes or 'None'}"""
-
-    parsed = await call_openai(client, model, LICENSE_SYSTEM_PROMPT, user_msg)
-    if "error" in parsed:
-        raise HTTPException(500, parsed["error"])
-
-    if isinstance(parsed.get("journals"), list):
-        parsed["journals"] = await enrich_journals(parsed["journals"])
-
-    parsed["khazna"] = KHAZNA_DEPOSIT_CARD
-    return {"result": parsed}
-
-@app.post("/api/find-repository")
-async def find_repository(req: RepoRequest):
-    model = req.model if req.model in ("gpt-4o-mini", "gpt-4o") else "gpt-4o-mini"
-    client = get_client()
-    user_msg = f"""Recommend research data repositories for this dataset. Return JSON only.
-
-DATASET INPUT:
-{json.dumps(req.dataset.dict(), indent=2)}"""
-
-    parsed = await call_openai(client, model, REPO_SYSTEM_PROMPT, user_msg)
-    if "error" in parsed:
-        raise HTTPException(500, parsed["error"])
-
-    # Ensure Khazna is always first in repositories list
-    repos = parsed.get("repositories", [])
-    has_khazna = any(r.get("is_khazna") or "khazna" in r.get("url","").lower() for r in repos)
-    if not has_khazna:
-        repos.insert(0, KHAZNA)
-    else:
-        repos = [r for r in repos if not (r.get("is_khazna") or "khazna" in r.get("url","").lower())]
-        repos.insert(0, KHAZNA)
-    # Add verify links to all non-Khazna repos
-    for r in repos:
-        if not r.get("is_khazna"):
-            clean_name = re.sub(r'[^\w\s]', '', r.get('name', ''))
-            r["verify_links"] = {
-                "re3data":     f"https://www.re3data.org/search?query={clean_name}",
-                "fairsharing": f"https://fairsharing.org/search?q={clean_name}",
-            }
-    parsed["repositories"] = repos
-    return {"result": parsed}
-
-# ── Static frontend ────────────────────────────────────────────────────────
-
-# ── Subject browse request model ───────────────────────────────────────────
-class SubjectRequest(BaseModel):
-    subject: str
-    model: str = "gpt-4o-mini"
-
-@app.post("/api/browse-subject")
-async def browse_subject(req: SubjectRequest):
-    """
-    NEW endpoint: normalise user subject via GPT, search SCImago CSV,
-    return top 15 journals with quartile + verify links.
-    Does NOT affect any existing endpoint.
-    """
-    if not req.subject or not req.subject.strip():
-        raise HTTPException(400, "Subject cannot be empty")
-
-    model = req.model if req.model in ("gpt-4o-mini", "gpt-4o") else "gpt-4o-mini"
-    client = get_client()
-
-    # Step 1 — GPT normalises the subject
-    parsed = await call_openai(
-        client, model,
-        SUBJECT_NORMALISE_PROMPT,
-        f"Subject input: {req.subject.strip()}"
-    )
-
-    confidence   = parsed.get("confidence", "not_found")
-    normalised   = parsed.get("normalised", req.subject)
-    category     = parsed.get("scimago_category", "")
-    area         = parsed.get("scimago_area", "")
-    user_message = parsed.get("user_message")
-
-    # Step 2 — if not_found, return early
-    if confidence == "not_found":
-        return {
-            "result": {
-                "confidence":   "not_found",
-                "normalised":   normalised,
-                "user_message": user_message or f"Could not identify a valid academic subject for '{req.subject}'. Try terms like: Computer Science, Medicine, Engineering, Physics.",
-                "journals":     []
-            }
-        }
-
-    # Step 3 — search SCImago CSV
-    journals = search_by_subject(category, area, top_n=15)
-
-    # Step 4 — if no CSV match, try broader area search
-    fallback_used = False
-    if not journals and area:
-        journals = search_by_subject("", area, top_n=15)
-        fallback_used = True
-
-    if not journals:
-        return {
-            "result": {
-                "confidence":   "not_found",
-                "normalised":   normalised,
-                "user_message": f"No journals found for '{normalised}' in our database. Try a broader term.",
-                "journals":     []
-            }
-        }
-
-    # Step 5 — enrich each journal with verify links
-    enriched = []
-    for j in journals:
-        issn = j.get("issn")
-        vl = build_verify_links(j["title"], issn)
-        q = j.get("quartile", "")
-        enriched.append({
-            "name":       j["title"],
-            "issn":       issn or "",
-            "quartile":   q if q and q != "-" else None,
-            "h_index":    j.get("h_index"),
-            "publisher":  j.get("publisher", ""),
-            "open_access":j.get("open_access", "No"),
-            "country":    j.get("country", ""),
-            "categories": j.get("categories", ""),
-            "verify_links": vl,
-        })
-
-    msg = user_message
-    if fallback_used and not msg:
-        msg = f"Exact category not found. Showing top journals in the broader '{area}' area."
 
+@app.get("/config")
+def public_config():
+    """Legacy public config endpoint — frontend uses /admin/public-config instead."""
+    settings = get_settings()
     return {
-        "result": {
-            "confidence":   confidence,
-            "normalised":   normalised,
-            "scimago_category": category,
-            "scimago_area": area,
-            "user_message": msg,
-            "journals":     enriched,
-            "total":        len(enriched),
-        }
+        "welcome_message": "Hi! I'm LibBee, the Khalifa University Library AI Assistant.",
+        "max_results": settings.max_results,
+        "maintenance_mode": settings.maintenance_mode,
     }
 
-@app.get("/")
-async def root():
-    if os.path.exists("static/index.html"):
-        return FileResponse("static/index.html")
-    return {"status": "Research Navigator API running", "docs": "/docs"}
-
-if os.path.exists("static"):
-    if os.path.exists("static/css"):
-        app.mount("/css", StaticFiles(directory="static/css"), name="css")
-    if os.path.exists("static/js"):
-        app.mount("/js",  StaticFiles(directory="static/js"),  name="js")
+
+@app.get("/year")
+def get_year():
+    from datetime import datetime
+    now = datetime.utcnow()
+    return {"year": now.year, "month": now.month, "date": now.strftime("%Y-%m-%d")}