Upload 2 files

src/api/agent.py

@@ -213,11 +213,6 @@ SUMMARY_RE = re.compile(
     re.IGNORECASE,
 )
 
-BEST_DATABASES_RE = re.compile(
-    r"\b(best databases?|which databases?|which database|best database|recommended databases?)\b",
-    re.IGNORECASE,
-)
-
 MEDICAL_KEYWORDS = [
     "medicine", "medical", "health", "clinical", "nursing", "pharmacy", "biomedical",
     "anatomy", "physiology", "epidemiology", "oncology", "cardiology", "neuroscience",
@@ -229,6 +224,11 @@ MEDICAL_KEYWORDS = [
     "crispr", "gene therapy", "gene editing", "genomic medicine", "precision medicine",
 ]
 
+DATABASE_RECOMMEND_RE = re.compile(
+    r"\b(best database|best databases|which database|which databases|database for|databases for|where should i search|where should i start)\b",
+    re.IGNORECASE,
+)
+
 REFINEMENT_STOP_WORDS = {
     "make", "it", "them", "those", "these", "the", "a", "an", "for", "to", "only", "show",
     "find", "give", "me", "please", "and", "with", "within", "limit", "narrow", "search",
@@ -478,7 +478,7 @@ async def _llm_classify(question: str, history: List[ChatMessage], model: str) -
             if m.role in ("user", "assistant")
         ]
         ctx = " | ".join(ctx_parts) if ctx_parts else "none"
-        llm = _get_llm(model, temperature=0, max_tokens=120)
+        llm = _get_llm(model, temperature=0, max_tokens=150)
         response = await llm.ainvoke([
             {"role": "system", "content": _CLASSIFIER_SYSTEM},
             {"role": "user", "content": f"Message: {question[:400]}\nContext: {ctx}\nJSON:"},
@@ -496,930 +496,6 @@ async def _llm_classify(question: str, history: List[ChatMessage], model: str) -
         return _rule_based_classify(question)
 
 
-async def _libbee_casual_response(question: str, history: List[ChatMessage], model: str, hint: str = "") -> str:
-    if hint and len(hint.strip()) > 20:
-        return hint.strip()
-    settings = get_settings()
-    if not settings.openai_api_key:
-        return "I'm <strong>LibBee</strong>, the Khalifa University Library AI Assistant — always happy to help!"
-    try:
-        llm = _get_llm(model, temperature=0.6, max_tokens=160)
-        msgs = [{"role": "system", "content": (
-            "You are LibBee, the Khalifa University Library AI Assistant. "
-            "Respond warmly and naturally in 1-3 sentences as a friendly librarian. "
-            "No markdown, no bullet points."
-        )}]
-        msgs.extend(_build_history_messages(history))
-        msgs.append({"role": "user", "content": question})
-        response = await llm.ainvoke(msgs)
-        return response.content.strip()
-    except Exception:
-        return "I'm <strong>LibBee</strong>, the Khalifa University Library AI Assistant — always happy to help!"
-
-
-async def _rag_answer(question: str, rag_results: List[dict], history: List[ChatMessage], model: str) -> str:
-    settings = get_settings()
-    if not settings.openai_api_key:
-        return rag_results[0]["content"] if rag_results else ""
-    context = "\n\n---\n\n".join(r["content"] for r in rag_results)
-    system = (
-        "You are LibBee, the Khalifa University Library AI Assistant. "
-        "Answer the user's question using ONLY the context provided below. "
-        "Be concise, friendly, and use HTML <br> for line breaks where needed. "
-        f"If the context does not contain enough information, say so and suggest Ask a Librarian at {ASK_LIBRARIAN_URL}. "
-        "Never invent facts or URLs.\n\n"
-        f"CONTEXT:\n{context}"
-    )
-    try:
-        llm = _get_llm(model, temperature=0.2, max_tokens=380)
-        msgs = [{"role": "system", "content": system}]
-        msgs.extend(_build_history_messages(history))
-        msgs.append({"role": "user", "content": question})
-        response = await llm.ainvoke(msgs)
-        return response.content.strip()
-    except Exception as e:
-        logger.error(f"_rag_answer error: {e}")
-        return (
-            "I'm having trouble generating an answer right now. "
-            f'Please try <a href="{ASK_LIBRARIAN_URL}" target="_blank">Ask a Librarian</a>.'
-        )
-
-
-async def _llm_general_answer(question: str, history: List[ChatMessage], model: str) -> str:
-    settings = get_settings()
-    if not settings.openai_api_key:
-        return (
-            "I'm <strong>LibBee</strong>, the KU Library AI Assistant. "
-            f'For general university information, visit <a href="{KU_MAIN_URL}" target="_blank">ku.ac.ae</a>.'
-        )
-    system = (
-        "You are LibBee, the Khalifa University Library AI Assistant (Abu Dhabi, UAE). "
-        "Answer factually and concisely in 3-5 sentences. Use HTML <br> for line breaks. "
-        "KU means Khalifa University. If the topic is academic, briefly offer to help find library resources."
-    )
-    try:
-        llm = _get_llm(model, temperature=0.3, max_tokens=360)
-        msgs = [{"role": "system", "content": system}]
-        msgs.extend(_build_history_messages(history))
-        msgs.append({"role": "user", "content": question})
-        response = await llm.ainvoke(msgs)
-        return response.content.strip()
-    except Exception as e:
-        logger.error(f"_llm_general_answer error: {e}")
-        return f'Having trouble right now. Visit <a href="{KU_MAIN_URL}" target="_blank">ku.ac.ae</a>.'
-
-
-async def _web_search_answer(question: str, history: List[ChatMessage], model: str) -> str:
-    settings = get_settings()
-    if model == "claude" and settings.anthropic_api_key:
-        try:
-            import anthropic
-            client = anthropic.Anthropic(api_key=settings.anthropic_api_key)
-            response = client.messages.create(
-                model="claude-3-haiku-20240307",
-                max_tokens=520,
-                system=(
-                    "You are LibBee, the Khalifa University Library AI Assistant (Abu Dhabi, UAE). "
-                    "Answer using current web search. Be concise and factual. Use HTML <br> for line breaks."
-                ),
-                tools=[{"type": "web_search_20250305", "name": "web_search"}],
-                messages=[{"role": "user", "content": question}],
-            )
-            text = "".join(block.text for block in response.content if hasattr(block, "text"))
-            if text.strip():
-                return text.strip()
-        except Exception as e:
-            logger.warning(f"Claude web search failed: {e}")
-
-    if settings.openai_api_key:
-        try:
-            from openai import OpenAI
-            client = OpenAI(api_key=settings.openai_api_key)
-            response = client.responses.create(
-                model="gpt-4o-mini",
-                tools=[{"type": "web_search_preview"}],
-                instructions=(
-                    "You are LibBee, the Khalifa University Library AI Assistant (Abu Dhabi, UAE). "
-                    "Answer using current web search. Be concise and factual. Use HTML <br> for line breaks."
-                ),
-                input=question,
-            )
-            text = ""
-            for item in response.output:
-                if hasattr(item, "content"):
-                    for block in item.content:
-                        if hasattr(block, "text"):
-                            text += block.text
-            if text.strip():
-                return text.strip()
-        except Exception as e:
-            logger.warning(f"GPT web search failed: {e}")
-
-    return await _llm_general_answer(question, history, model)
-
-
-# ── Topic Extraction ──────────────────────────────────────────────────────────
-
-def _extract_topic_regex(question: str) -> str:
-    """Fast regex-based topic extraction — strips boilerplate prefixes and filter words."""
-    q = _normalize_whitespace(question)
-    prefixes = [
-        "can u give me a deep analysis of ", "can you give me a deep analysis of ",
-        "give me a deep analysis of ", "deep analysis of ",
-        "give me a summary of ", "give me a summary on ", "give me a summary about ",
-        "give me an overview of ", "give me an overview on ",
-        "give me a brief overview of ", "give me a brief summary of ",
-        "summarize the latest studies in ", "summarize latest studies in ",
-        "summarize the latest research on ", "summarize latest research on ",
-        "summarize recent studies in ", "summarize recent research on ",
-        "latest studies in ", "latest research on ", "recent studies in ", "recent research on ",
-        "summarize ", "summarise ", "summary of ", "summary on ", "summary about ",
-        "overview of ", "overview on ", "brief overview of ", "brief summary of ",
-        "analysis of ", "analyze ", "analyse ", "explain ", "tell me about ",
-        "what is ", "what are ", "describe ", "review of ", "literature review on ",
-        "recent advances in ", "recent developments in ", "state of the art in ",
-        "state of research on ", "research overview of ", "research summary of ",
-        "find peer reviewed articles on ", "find peer reviewed papers on ",
-        "find articles on ", "find papers on ", "find books on ", "find articles about ",
-        "find papers about ", "search for articles on ", "search for papers on ",
-        "i need peer reviewed articles on ", "i need articles on ", "i need papers on ",
-        "i need books on ", "give me articles on ", "show me articles on ",
-        "get me articles on ", "look for articles on ", "articles on ", "papers on ",
-        "books on ", "research on ", "literature on ", "find ", "search for ",
-        "i need ", "give me ", "show me ", "get me ",
-    ]
-    lower = q.lower()
-    for prefix in prefixes:
-        if lower.startswith(prefix):
-            q = q[len(prefix):]
-            break
-    # Strip trailing noise
-    q = re.sub(r"\s+(please|thanks|thank you)\.?$", "", q, flags=re.IGNORECASE)
-    q = re.sub(r"\b(peer[- ]reviewed|open access|last \d+ years?|past \d+ years?)\b", "", q, flags=re.IGNORECASE)
-    # FIX: strip resource-type words that leaked through prefix stripping
-    q = _strip_resource_noise(q)
-    return _normalize_whitespace(q).strip(".?")
-
-
-async def _extract_topic(question: str, model: str) -> str:
-    """
-    LLM-based topic extraction.
-    CRITICAL: instructs LLM to never return resource-type words (articles/books/papers).
-    Falls back to regex if LLM unavailable or returns empty.
-    """
-    settings = get_settings()
-    if not settings.openai_api_key:
-        return _extract_topic_regex(question)
-    try:
-        llm = _get_llm(model, temperature=0, max_tokens=32)
-        response = await llm.ainvoke([
-            {"role": "system", "content": (
-                "Extract only the core research topic from the user's question. "
-                "Return 2-7 keywords ONLY — no punctuation, no sentence, no explanation. "
-                "CRITICAL: do NOT include words like articles, papers, books, journals, "
-                "peer-reviewed, open-access, studies, or research in your output. "
-                "Those are filters, not topic words. Return ONLY the subject matter.\n"
-                "Examples:\n"
-                "'find articles on indian politics' → indian politics\n"
-                "'peer reviewed papers on climate change 2020' → climate change\n"
-                "'books on structural engineering UAE' → structural engineering UAE\n"
-                "'give me a summary of quantum physics advances' → quantum physics advances\n"
-                "'i need peer reviewed research on machine learning healthcare' → machine learning healthcare"
-            )},
-            {"role": "user", "content": question},
-        ])
-        topic = response.content.strip().strip('"').strip("'").strip(".")
-        # Belt-and-braces: strip any noise the LLM snuck in anyway
-        topic = _strip_resource_noise(topic)
-        topic = _normalize_whitespace(topic).strip(".?")
-        if topic and len(topic) > 2:
-            logger.info(f"LLM topic: '{topic}' ← '{question[:60]}'")
-            return topic
-    except Exception as e:
-        logger.warning(f"Topic extraction failed: {e}")
-    return _extract_topic_regex(question)
-
-
-# ── Query Building ────────────────────────────────────────────────────────────
-
-def _derive_resource_type(question: str, existing: Optional[str] = None) -> str:
-    q = (question or "").lower()
-    if any(token in q for token in ["book", "books", "ebook", "ebooks"]):
-        return "books"
-    if any(token in q for token in ["article", "articles", "paper", "papers", "study", "studies", "journal", "journals"]):
-        return "articles"
-    return existing or "articles"
-
-
-def _parse_year_filters(question: str) -> Tuple[Optional[str], Optional[str]]:
-    q = (question or "").lower()
-    match = re.search(r"\b(last|past)\s+(\d{1,2})\s+years?\b", q)
-    if match:
-        years = int(match.group(2))
-        return str(CURRENT_YEAR - years + 1), str(CURRENT_YEAR)
-    between = re.search(r"\b(?:from|between)\s+(20\d{2}|19\d{2})\s+(?:to|and|-)\s+(20\d{2}|19\d{2})\b", q)
-    if between:
-        return between.group(1), between.group(2)
-    years = re.findall(r"\b(19\d{2}|20\d{2})\b", q)
-    if len(years) >= 2:
-        return min(years), max(years)
-    if len(years) == 1 and any(word in q for word in ["since", "from", "after"]):
-        return years[0], str(CURRENT_YEAR)
-    return None, None
-
-
-def _make_primo_boolean_query(context: SearchContextPayload) -> str:
-    """
-    FIX: Build a clean boolean for display purposes ONLY.
-    Contains ONLY topic keywords — NO resource-type words.
-    Resource type is expressed as a PRIMO facet in search_primo(), never here.
-    """
-    topic = _title_case_topic(context.display_topic or context.topic)
-    # Strip any remaining noise one final time
-    topic = _strip_resource_noise(topic)
-    if not topic:
-        topic = context.topic or "library search"
-    return f'"{_normalize_whitespace(topic)}"'
-
-
-def _primo_clean_url(context: SearchContextPayload) -> str:
-    """
-    Build the PRIMO discovery URL using the clean topic — matching exactly what the API searches.
-    """
-    clean_topic = _strip_resource_noise(context.topic)
-    if not clean_topic:
-        clean_topic = context.topic
-    return f"{PRIMO_BASE_URL}&query=any,contains,{quote(clean_topic)}&lang=en&mode=advanced&offset=0"
-
-
-def _topic_keywords(text: str) -> List[str]:
-    cleaned = _normalize_whitespace(re.sub(r"[^a-zA-Z0-9\s-]", " ", text or ""))
-    stop = {
-        "of", "on", "in", "the", "a", "an", "and", "or", "for", "to", "with", "by", "from", "at",
-        "is", "are", "was", "were", "be", "been", "have", "has", "had", "do", "does", "did", "will",
-        "would", "could", "should", "may", "its", "this", "that", "these", "those", "about", "impact",
-        "role", "effect", "use", "study", "analysis", "review", "what", "how", "why", "when", "where",
-        "which", "recent", "latest", "current", "summary", "summarize", "overview", "brief",
-        # FIX: resource-type words must never appear as keywords
-        "research", "studies", "articles", "article", "papers", "paper", "books", "book",
-        "journals", "journal", "publications", "publication",
-    }
-    tokens: List[str] = []
-    for word in cleaned.split():
-        word = word.strip("-").lower()
-        if not word or word in stop or len(word) < 3:
-            continue
-        if word not in tokens:
-            tokens.append(word)
-    return tokens[:6]
-
-
-def _compose_ai_tool_query(question: str, context: SearchContextPayload, is_follow_up: bool) -> str:
-    """Build the clean natural language query for AI tools (LeapSpace, Scopus AI, Consensus)."""
-    topic = context.display_topic or context.topic
-    topic = _title_case_topic(topic)
-    scope = context.resource_type
-    filters = []
-    if context.peer_reviewed:
-        filters.append("peer-reviewed")
-    if context.open_access:
-        filters.append("open-access")
-    if context.year_from and context.year_to:
-        filters.append(f"published between {context.year_from} and {context.year_to}")
-    elif context.year_from:
-        filters.append(f"published from {context.year_from} onward")
-
-    if is_follow_up:
-        if scope == "books":
-            base = f"Find books on {topic}"
-        elif scope == "both":
-            base = f"Find articles and books on {topic}"
-        else:
-            base = f"Find research articles on {topic}"
-    else:
-        base = _normalize_whitespace(question).strip(".?")
-        if len(base.split()) < 4:
-            base = f"Find research on {topic}"
-
-    if filters:
-        return f"{base} with {', '.join(filters)}."
-    return base.rstrip(".") + "."
-
-
-async def _grammar_refine_query(text: str, model: str) -> str:
-    settings = get_settings()
-    if not settings.openai_api_key:
-        return _normalize_whitespace(text)
-    try:
-        llm = _get_llm(model, temperature=0, max_tokens=60)
-        response = await llm.ainvoke([
-            {"role": "system", "content": "Rewrite the user's search question in clear grammatical English. Keep the meaning exactly the same. Return one sentence only."},
-            {"role": "user", "content": text},
-        ])
-        refined = _normalize_whitespace(response.content)
-        return refined or _normalize_whitespace(text)
-    except Exception:
-        return _normalize_whitespace(text)
-
-
-def _context_to_dict(context: SearchContextPayload) -> dict:
-    return context.model_dump()
-
-
-async def _prepare_queries(question: str, context: SearchContextPayload, model: str, is_follow_up: bool) -> SearchContextPayload:
-    """Populate ai_tool_query and primo_boolean_query on the context."""
-    natural = _compose_ai_tool_query(question, context, is_follow_up)
-    natural = await _grammar_refine_query(natural, model)
-    context.ai_tool_query = natural
-    # FIX: boolean is now clean topic only — resource type goes to PRIMO as a facet
-    context.primo_boolean_query = _make_primo_boolean_query(context)
-    return context
-
-
-# ── Semantic Scholar + Summary ────────────────────────────────────────────────
-
-async def _semantic_scholar_search(topic: str, limit: int = 8) -> List[dict]:
-    """Search Semantic Scholar. Returns only papers that have abstracts."""
-    # FIX: strip resource noise from topic before hitting external API
-    clean_topic = _strip_resource_noise(topic)
-    if not clean_topic:
-        clean_topic = topic
-    try:
-        params = {
-            "query": clean_topic,
-            "limit": limit,
-            "fields": "title,authors,year,venue,abstract,externalIds,openAccessPdf",
-        }
-        async with httpx.AsyncClient(timeout=15) as client:
-            r = await client.get("https://api.semanticscholar.org/graph/v1/paper/search", params=params)
-            if r.status_code != 200:
-                logger.warning(f"Semantic Scholar {r.status_code} for '{clean_topic}'")
-                return []
-            data = r.json()
-            results = []
-            for paper in data.get("data", []):
-                abstract = paper.get("abstract") or ""
-                if not abstract or len(abstract) < 50:
-                    continue
-                author_list = paper.get("authors") or []
-                first_author_last = author_list[0].get("name", "Unknown").split()[-1] if author_list else "Unknown"
-                year = paper.get("year") or "n.d."
-                paper_id = paper.get("paperId", "")
-                doi = (paper.get("externalIds") or {}).get("DOI", "")
-                pdf_url = (paper.get("openAccessPdf") or {}).get("url", "")
-                link = (
-                    pdf_url
-                    or (f"https://doi.org/{doi}" if doi else "")
-                    or (f"https://www.semanticscholar.org/paper/{paper_id}" if paper_id else "#")
-                )
-                results.append({
-                    "title": paper.get("title", "Untitled"),
-                    "authors": (
-                        ", ".join(a.get("name", "") for a in author_list[:3])
-                        + (" et al." if len(author_list) > 3 else "")
-                    ),
-                    "first_author": first_author_last,
-                    "year": year,
-                    "citation_key": f"{first_author_last}, {year}",
-                    "venue": paper.get("venue", ""),
-                    "abstract": abstract[:700],
-                    "link": link,
-                    "_source": "Semantic Scholar",
-                })
-            logger.info(f"Semantic Scholar: {len(results)} papers with abstracts for '{clean_topic}'")
-            return results
-    except Exception as e:
-        logger.error(f"Semantic Scholar search failed: {e}")
-        return []
-
-
-async def _generate_cited_summary(topic: str, papers: List[dict], model: str) -> str:
-    """
-    Generate a research summary with clickable in-text citations [Author, Year].
-    Each [N] in the LLM output is replaced with a hyperlink to the actual paper.
-    """
-    settings = get_settings()
-    if not settings.openai_api_key or not papers:
-        return ""
-
-    context_text = ""
-    for i, paper in enumerate(papers, 1):
-        context_text += (
-            f"[{i}] {paper['citation_key']}: {paper['title']}\n"
-            f"Abstract: {paper['abstract']}\n\n"
-        )
-
-    system = (
-        "You are a research librarian writing a concise academic literature snapshot. "
-        "Using ONLY the numbered references provided, write a 4-6 sentence summary on the given topic. "
-        "Use in-text citations as [1], [2], [3] etc. referring to the numbered references. "
-        "Cite at least 4 different references. "
-        "Use HTML <br><br> for paragraph breaks. Do not use bullet points or markdown. "
-        "Only state what is explicitly supported by the abstracts. "
-        "Do NOT invent content."
-    )
-
-    try:
-        llm = _get_llm(model, temperature=0.2, max_tokens=560)
-        response = await llm.ainvoke([
-            {"role": "system", "content": system},
-            {"role": "user", "content": f"Topic: {topic}\n\nReferences:\n{context_text}\nWrite the summary."},
-        ])
-        summary = response.content.strip()
-
-        # Replace [N] with clickable citation links — work backwards to avoid [1] matching inside [10]
-        for i in range(len(papers), 0, -1):
-            paper = papers[i - 1]
-            title_escaped = _escape(paper["title"])
-            cite_html = (
-                f'<a href="{paper["link"]}" target="_blank" '
-                f'title="{title_escaped}" '
-                f'style="color:#1e40af;font-weight:600;text-decoration:none">'
-                f'[{paper["citation_key"]}]</a>'
-            )
-            summary = summary.replace(f"[{i}]", cite_html)
-        return summary
-    except Exception as e:
-        logger.error(f"Summary generation failed: {e}")
-        return ""
-
-
-def _extractive_snapshot_from_papers(topic: str, papers: List[dict]) -> str:
-    """Fallback: extract lead sentences from abstracts when LLM summary fails."""
-    if not papers:
-        return ""
-    statements: List[str] = []
-    for paper in papers[:4]:
-        sentences = re.split(r"(?<=[.!?])\s+", paper.get("abstract", ""))
-        lead = sentences[0].strip() if sentences else ""
-        if not lead:
-            continue
-        citation = (
-            f'<a href="{paper["link"]}" target="_blank" '
-            f'style="color:#1e40af;font-weight:600;text-decoration:none">'
-            f'[{_escape(paper["citation_key"])}]</a>'
-        )
-        statements.append(f"{_escape(lead)} {citation}")
-    if not statements:
-        return f"Recent literature on <strong>{_escape(topic)}</strong> is available in the cited papers below."
-    intro = f"Recent literature on <strong>{_escape(topic)}</strong>:<br><br>"
-    return intro + "<br><br>".join(statements[:4])
-
-
-# ── PRIMO / PubMed Search Wrappers ────────────────────────────────────────────
-
-from src.api.search import SearchRequest, search_primo, search_pubmed
-
-
-async def _search_primo_catalog(context: SearchContextPayload, limit: int = 5) -> Tuple[dict, str]:
-    """
-    FIX: now passes resource_type so the rtype FACET is correctly sent to PRIMO.
-    Topic is stripped of noise before hitting the API.
-    """
-    settings = get_settings()
-    # FIX: strip resource noise from topic — belt-and-braces
-    clean_topic = _strip_resource_noise(context.topic)
-    if not clean_topic:
-        clean_topic = context.topic
-
-    result = await search_primo(
-        SearchRequest(
-            query=clean_topic,
-            source="primo",
-            limit=limit,
-            peer_reviewed=context.peer_reviewed,
-            open_access=context.open_access,
-            year_from=context.year_from,
-            year_to=context.year_to,
-            resource_type=context.resource_type,  # FIX: was missing — resource type now goes as facet
-        ),
-        settings.primo_api_key,
-    )
-    source_url = _primo_clean_url(context)
-    return result, source_url
-
-
-async def _search_pubmed_articles(context: SearchContextPayload, limit: int = 5) -> Tuple[dict, str]:
-    """
-    FIX: year_from/year_to now correctly wired through SearchRequest → mindate/maxdate in search.py.
-    """
-    clean_topic = _strip_resource_noise(context.topic)
-    if not clean_topic:
-        clean_topic = context.topic
-
-    result = await search_pubmed(
-        SearchRequest(
-            query=clean_topic,
-            source="pubmed",
-            limit=limit,
-            peer_reviewed=context.peer_reviewed,
-            year_from=context.year_from,   # FIX: now actually used in search.py
-            year_to=context.year_to,       # FIX: now actually used in search.py
-        )
-    )
-    pubmed_url = f"https://pubmed.ncbi.nlm.nih.gov/?term={quote(clean_topic)}"
-    if context.year_from and context.year_to:
-        pubmed_url += f"&filter=datesearch.y_custom&dates.from={context.year_from}&dates.to={context.year_to}"
-    return result, pubmed_url
-
-
-# ── AI Tools / Database Guidance ─────────────────────────────────────────────
-
-def _tool_urls(context: SearchContextPayload) -> Dict[str, str]:
-    ai_query = quote(context.ai_tool_query or context.display_topic or context.topic)
-    clean_topic = _strip_resource_noise(context.topic)
-    return {
-        "leapspace": f"https://www.sciencedirect.com/leapspace?query={ai_query}",
-        "scopus_ai": f"https://www-scopus-com.khalifa.idm.oclc.org/pages/ai?query={ai_query}",
-        "consensus": f"https://consensus.app/results/?q={ai_query}",
-        "primo_discovery": _primo_clean_url(context),
-    }
-
-
-def _ai_source_links_html(context: SearchContextPayload) -> str:
-    urls = _tool_urls(context)
-    return (
-        f'<a href="{urls["leapspace"]}" target="_blank" style="color:#9a3412;font-weight:700;text-decoration:none">LeapSpace</a> · '
-        f'<a href="{urls["scopus_ai"]}" target="_blank" style="color:#1e40af;font-weight:700;text-decoration:none">Scopus AI</a> · '
-        f'<a href="{urls["consensus"]}" target="_blank" style="color:#86198f;font-weight:700;text-decoration:none">Consensus</a> · '
-        f'<a href="{urls["primo_discovery"]}" target="_blank" style="color:#5b21b6;font-weight:700;text-decoration:none">PRIMO Library Discovery</a>'
-    )
-
-
-def _database_guidance_for_topic(context: SearchContextPayload) -> str:
-    topic = _escape(context.display_topic or context.topic)
-    links = _ai_source_links_html(context)
-    if context.intent == "search_medical":
-        return (
-            f"For a stronger evidence trail on <strong>{topic}</strong>, start with <strong>PubMed</strong> or <strong>Embase</strong> for the core medical literature, "
-            f"then continue with {links}."
-        )
-    return (
-        f"For deeper work on <strong>{topic}</strong>, continue with {links}. "
-        "Use Scopus AI for broader scholarly mapping, LeapSpace for guided evidence exploration, "
-        "Consensus for quick paper-grounded answers, and PRIMO Library Discovery for KU-accessible material."
-    )
-
-
-def _looks_database_recommendation_question(question: str) -> bool:
-    q = (question or "").lower()
-    return bool(BEST_DATABASES_RE.search(q)) and any(kw in q for kw in [
-        "database", "databases", "subject", "engineering", "medicine", "medical", "ai", "computer",
-        "physics", "chemistry", "chemical", "civil", "mechanical", "electrical", "business",
-        "biomedical", "nursing", "systematic review", "health"
-    ])
-
-
-def _database_recommendation_payload(question: str) -> Dict[str, Any]:
-    q = (question or "").lower()
-    general = {
-        "title": "General / multidisciplinary research",
-        "intro": "These are the best starting databases for broad academic searching at KU.",
-        "items": [
-            {"name": "PRIMO Library Discovery", "url": "https://khalifa.primo.exlibrisgroup.com/discovery/search?vid=971KUOSTAR_INST:KU", "why": "Best first stop for KU-accessible books, articles, journals, and holdings."},
-            {"name": "Scopus", "url": "https://khalifa.idm.oclc.org/login?url=https://www.scopus.com", "why": "Broad multidisciplinary database for scholarly discovery and citation tracking."},
-            {"name": "Web of Science", "url": "https://khalifa.idm.oclc.org/login?url=https://www.webofscience.com", "why": "Strong citation database for high-level literature mapping and journal evaluation."},
-            {"name": "ScienceDirect", "url": "https://khalifa.idm.oclc.org/login?url=https://www.sciencedirect.com", "why": "Large full-text platform across science, engineering, and medicine."},
-        ],
-    }
-    subjects = [
-        (["systematic review", "medicine", "medical", "health", "nursing", "clinical", "biomedical", "pharmacy"], {
-            "title": "Medical and health sciences",
-            "intro": "For medical evidence and subject searching, start with these databases.",
-            "items": [
-                {"name": "PubMed@KU", "url": "http://www.ncbi.nlm.nih.gov/pubmed/?otool=iaekustlib", "why": "Core biomedical literature with KU full-text linking."},
-                {"name": "Embase", "url": "https://khalifa.idm.oclc.org/login?url=https://www.embase.com", "why": "Excellent for biomedical, drugs, devices, and evidence searching."},
-                {"name": "CINAHL Ultimate", "url": "https://khalifa.idm.oclc.org/login?url=https://search.ebscohost.com/login.aspx?authtype=ip,uid&profile=ehost&defaultdb=cul", "why": "Best for nursing and allied health literature."},
-                {"name": "Cochrane Library", "url": "https://khalifa.idm.oclc.org/login?url=https://www.cochranelibrary.com", "why": "Key source for systematic reviews and evidence-based medicine."},
-                {"name": "UpToDate", "url": "https://khalifa.idm.oclc.org/login?url=https://www.uptodate.com", "why": "Clinical point-of-care resource for evidence summaries."},
-            ],
-        }),
-        (["computer science", "machine learning", "artificial intelligence", " ai", "cyber", "software", "algorithm", "computer", "data science"], {
-            "title": "Computer science and AI",
-            "intro": "For computing, AI, software, and algorithms, these are the best starting points.",
-            "items": [
-                {"name": "ACM Digital Library", "url": "https://khalifa.idm.oclc.org/login?url=https://dl.acm.org", "why": "Core computer science literature."},
-                {"name": "IEEE Xplore", "url": "https://khalifa.idm.oclc.org/login?url=https://ieeexplore.ieee.org", "why": "Strong for AI, computing systems, networks, and engineering."},
-                {"name": "arXiv", "url": "https://arxiv.org", "why": "Useful for fast-moving preprints in AI and computer science."},
-                {"name": "Scopus", "url": "https://khalifa.idm.oclc.org/login?url=https://www.scopus.com", "why": "Good for citation tracking and broader discovery."},
-            ],
-        }),
-        (["electrical", "electronics", "signals", "power systems", "communications"], {
-            "title": "Electrical engineering",
-            "intro": "For electrical engineering topics, start here.",
-            "items": [
-                {"name": "IEEE Xplore", "url": "https://khalifa.idm.oclc.org/login?url=https://ieeexplore.ieee.org", "why": "Core database for electrical engineering literature and standards."},
-                {"name": "INSPEC", "url": "https://khalifa.idm.oclc.org/login?url=https://www.theiet.org/publishing/inspec", "why": "Strong indexing for EE, electronics, communications, and computing."},
-                {"name": "ScienceDirect", "url": "https://khalifa.idm.oclc.org/login?url=https://www.sciencedirect.com", "why": "Good full-text coverage across electrical engineering and controls."},
-            ],
-        }),
-        (["mechanical", "thermo", "fluids", "manufacturing"], {
-            "title": "Mechanical engineering",
-            "intro": "For mechanical engineering, these are the strongest starts.",
-            "items": [
-                {"name": "ASME Digital Library", "url": "https://khalifa.idm.oclc.org/login?url=https://asmedigitalcollection.asme.org", "why": "Core mechanical engineering journals and conference papers."},
-                {"name": "Knovel", "url": "https://khalifa.idm.oclc.org/login?url=https://app.knovel.com", "why": "Engineering reference books and technical data."},
-                {"name": "ScienceDirect", "url": "https://khalifa.idm.oclc.org/login?url=https://www.sciencedirect.com", "why": "Strong full-text support for applied engineering topics."},
-            ],
-        }),
-        (["civil", "geotechnical", "transportation", "construction", "structures"], {
-            "title": "Civil engineering",
-            "intro": "For civil engineering and infrastructure topics, start here.",
-            "items": [
-                {"name": "ASCE Library", "url": "https://khalifa.idm.oclc.org/login?url=https://ascelibrary.org", "why": "Core civil engineering journals and conference papers."},
-                {"name": "ASTM Compass", "url": "https://khalifa.idm.oclc.org/login?url=https://compass.astm.org", "why": "Important standards and testing information for materials and engineering."},
-                {"name": "ScienceDirect", "url": "https://khalifa.idm.oclc.org/login?url=https://www.sciencedirect.com", "why": "Useful full-text coverage across civil engineering subjects."},
-            ],
-        }),
-        (["aerospace", "aerodynamics", "propulsion", "aircraft"], {
-            "title": "Aerospace engineering",
-            "intro": "For aerospace topics, these are the best databases to begin with.",
-            "items": [
-                {"name": "AIAA Aerospace Research Central", "url": "https://khalifa.idm.oclc.org/login?url=https://arc.aiaa.org/", "why": "Core aerospace journals and conference literature."},
-                {"name": "ASME Digital Library", "url": "https://khalifa.idm.oclc.org/login?url=https://asmedigitalcollection.asme.org", "why": "Useful for thermal, mechanical, and fluid systems relevant to aerospace."},
-                {"name": "ScienceDirect", "url": "https://khalifa.idm.oclc.org/login?url=https://www.sciencedirect.com", "why": "Good full-text support for aerospace materials and systems."},
-            ],
-        }),
-        (["chemical engineering", "catalysis", "separations", "chemistry", "chemical"], {
-            "title": "Chemistry and chemical engineering",
-            "intro": "For chemistry and chemical engineering, these are the strongest starting points.",
-            "items": [
-                {"name": "ACS Publications", "url": "https://khalifa.idm.oclc.org/login?url=https://pubs.acs.org", "why": "Core chemistry journals."},
-                {"name": "SciFindern", "url": "https://khalifa.idm.oclc.org/login?url=https://scifinder-n.cas.org", "why": "Best for substances, reactions, and chemistry references."},
-                {"name": "Reaxys", "url": "https://khalifa.idm.oclc.org/login?url=https://www.reaxys.com", "why": "Useful for chemistry reactions and property searching."},
-                {"name": "ScienceDirect", "url": "https://khalifa.idm.oclc.org/login?url=https://www.sciencedirect.com", "why": "Strong full-text source for chemical engineering journals."},
-            ],
-        }),
-        (["physics", "quantum", "optics", "plasma"], {
-            "title": "Physics",
-            "intro": "For physics topics, start with these databases and platforms.",
-            "items": [
-                {"name": "APS Journals", "url": "https://khalifa.idm.oclc.org/login?url=https://journals.aps.org", "why": "Core American Physical Society journals."},
-                {"name": "AIP", "url": "https://khalifa.idm.oclc.org/login?url=https://aip.scitation.org", "why": "Major physics and applied physics content."},
-                {"name": "arXiv", "url": "https://arxiv.org", "why": "Open preprints in physics and related areas."},
-            ],
-        }),
-        (["business", "management", "marketing", "economics", "finance"], {
-            "title": "Business and management",
-            "intro": "For business-related topics, start with these databases.",
-            "items": [
-                {"name": "Business Source Complete", "url": "https://khalifa.idm.oclc.org/login?url=https://search.ebscohost.com/login.aspx?authtype=ip,uid&profile=ehost&defaultdb=bsh", "why": "Comprehensive business database."},
-                {"name": "Emerald Insight", "url": "https://khalifa.idm.oclc.org/login?url=https://www.emerald.com/insight", "why": "Strong for management, marketing, and business journals."},
-                {"name": "ProQuest Databases", "url": "https://khalifa.idm.oclc.org/login?url=https://search.proquest.com", "why": "Broad business and dissertation coverage."},
-            ],
-        }),
-    ]
-    for keywords, payload in subjects:
-        if any(k in q for k in keywords):
-            return payload
-    return general
-
-
-def _database_recommendation_answer(question: str) -> str:
-    payload = _database_recommendation_payload(question)
-    answer = f"<strong>Best databases for { _escape(payload['title']) }</strong><br><br>{_escape(payload['intro'])}<br>"
-    for item in payload['items']:
-        answer += (
-            f'<br>• <a href="{item["url"]}" target="_blank" style="color:#003366;font-weight:600">{_escape(item["name"])}</a><br>'
-            f'<span style="font-size:.9rem;color:#4b5563">{_escape(item["why"])}</span>'
-        )
-    answer += (
-        f'<br><br>You can also start in <a href="{PRIMO_BASE_URL}" target="_blank">PRIMO Library Discovery</a> '
-        'and then narrow by resource type, date, and peer-reviewed content.'
-    )
-    answer += _source_badge("ku_library", "https://library.ku.ac.ae/eresources")
-    return answer
-
-
-# ── Research Snapshot ─────────────────────────────────────────────────────────
-
-async def _research_snapshot(context: SearchContextPayload, model: str) -> Tuple[str, List[dict], List[dict]]:
-    """
-    Full research snapshot:
-    1. Semantic Scholar → cited summary with hyperlinked [Author, Year] citations
-    2. PRIMO → KU-accessible results appended below
-    """
-    topic = context.topic
-    papers = await _semantic_scholar_search(topic, limit=8)
-    references: List[dict] = []
-    primo_result, primo_url = await _search_primo_catalog(context, limit=6)
-    search_results = primo_result.get("results", []) or []
-
-    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}"
-        if search_results:
-            answer += (
-                "<br><br><strong>KU Library starting points:</strong> "
-                "I also pulled KU-accessible results below so you can move directly from the snapshot to subscribed material."
-            )
-        answer += f"<br><br><strong>AI sources:</strong> {_database_guidance_for_topic(context)}"
-        answer += "<br><br><strong>Selected references:</strong><br>"
-        for i, paper in enumerate(papers[:6], 1):
-            answer += (
-                f'<br><strong>[{i}]</strong> '
-                f'<a href="{paper["link"]}" target="_blank" style="color:#003366;font-weight:600">{_escape(paper["title"])}</a><br>'
-                f'<span style="font-size:.8rem;color:#6b7280">'
-                f'{_escape(paper["authors"])} · {paper["year"]} · {_escape(paper["venue"] or "")}'
-                f'</span>'
-            )
-        answer += _source_badge("semantic", "https://www.semanticscholar.org/")
-        if search_results:
-            answer += _source_badge("primo", primo_url)
-        references = [{"title": p["title"], "url": p["link"]} for p in papers[:6]]
-        return answer, search_results, references
-
-    if search_results:
-        answer = (
-            f"<strong>📚 KU Library starting points on {_escape(topic)}</strong><br><br>"
-            "I couldn't build a Semantic Scholar snapshot right now, but here are KU-accessible library results you can open immediately. "
-            f"<br><br><strong>AI sources:</strong> {_database_guidance_for_topic(context)}"
-        )
-    else:
-        answer = (
-            f"I couldn't retrieve a research snapshot for <strong>{_escape(topic)}</strong> right now.<br><br>"
-            f"<strong>AI sources:</strong> {_database_guidance_for_topic(context)}"
-        )
-    answer += _source_badge("primo", primo_url)
-    return answer, search_results, []
-
-
-# ── Follow-up System ──────────────────────────────────────────────────────────
-
-def _filters_summary(context: SearchContextPayload) -> str:
-    filters: List[str] = []
-    if context.peer_reviewed:
-        filters.append("peer reviewed only")
-    if context.open_access:
-        filters.append("open access")
-    if context.year_from and context.year_to:
-        filters.append(f"{context.year_from}–{context.year_to}")
-    elif context.year_from:
-        filters.append(f"from {context.year_from}")
-    if context.resource_type == "books":
-        filters.append("books")
-    elif context.resource_type == "articles":
-        filters.append("articles")
-    elif context.resource_type == "both":
-        filters.append("articles and books")
-    return ", ".join(filters)
-
-
-def _question_has_new_topic(question: str, base_topic: str) -> bool:
-    q = (question or "").lower()
-    cleaned = re.sub(
-        r"\b(peer[- ]reviewed|open access|last \d+ years?|past \d+ years?|books? instead|articles? instead|"
-        r"summari[sz]e( this topic)?|overview|brief|use pubmed|search pubmed|search primo|best databases?|deep research tools?)\b",
-        " ", q,
-    )
-    tokens = [t for t in re.findall(r"[a-z0-9]+", cleaned) if t not in REFINEMENT_STOP_WORDS and len(t) > 2]
-    if len(tokens) < 3:
-        return False
-    base_tokens = {t for t in re.findall(r"[a-z0-9]+", (base_topic or "").lower()) if t not in REFINEMENT_STOP_WORDS}
-    overlap = sum(1 for t in tokens if t in base_tokens)
-    return overlap <= max(1, min(2, len(base_tokens)))
-
-
-def _parse_refinement_action(question: str) -> Optional[str]:
-    q = (question or "").lower().strip()
-    if re.search(r"\b(peer[- ]reviewed|peer reviewed only|peer reviewd|peer review only)\b", q):
-        return "peer_reviewed_only"
-    if re.search(r"\b(open access|oa only|only open access)\b", q):
-        return "open_access_only"
-    if re.search(r"\b(last|past)\s+5\s+years?\b", q):
-        return "last_5_years"
-    if re.search(r"\b(last|past)\s+10\s+years?\b|\bpast decade\b", q):
-        return "last_10_years"
-    if re.search(r"\bbooks? instead\b|\bbooks? only\b|\bfind books?\b|\bshow books?\b", q):
-        return "books_only"
-    if re.search(r"\barticles? instead\b|\barticles? only\b|\bpapers? only\b", q):
-        return "articles_only"
-    if re.search(r"\b(?:both|articles and books|books and articles)\b", q):
-        return "both_resources"
-    if re.search(r"\b(summar(y|ize|ise)|overview|brief|what does the literature say|research snapshot)\b", q):
-        return "summarize_topic"
-    if re.search(r"\bpubmed\b", q):
-        return "search_pubmed"
-    if re.search(r"\bprimo\b", q):
-        return "search_primo"
-    if re.search(r"\b(best database|best databases|which database|which databases)\b", q):
-        return "best_databases"
-    if re.search(r"\b(deep research|deep dive|full literature review|exhaustive)\b", q):
-        return "deep_research_tools"
-    return None
-
-
-def _resolve_base_context(client_state: Optional[ClientStatePayload]) -> Optional[SearchContextPayload]:
-    if not client_state or not client_state.recent_search_contexts:
-        return None
-    contexts = list(client_state.recent_search_contexts)
-    if client_state.follow_up_context_id:
-        for ctx in contexts:
-            if ctx.context_id == client_state.follow_up_context_id:
-                return ctx
-    if client_state.active_search_context_id:
-        for ctx in contexts:
-            if ctx.context_id == client_state.active_search_context_id:
-                return ctx
-    contexts.sort(key=lambda c: c.created_at, reverse=True)
-    return contexts[0]
-
-
-def _detect_follow_up(question: str, client_state: Optional[ClientStatePayload]) -> Tuple[bool, Optional[str], Optional[SearchContextPayload]]:
-    base_context = _resolve_base_context(client_state)
-    if not base_context:
-        return False, None, None
-    explicit_action = (client_state.follow_up_action if client_state else None) or None
-    if explicit_action:
-        return True, explicit_action, base_context
-    action = _parse_refinement_action(question)
-    if not action:
-        return False, None, None
-    if _question_has_new_topic(question, base_context.topic):
-        return False, None, None
-    return True, action, base_context
-
-
-def _clone_context(base_context: SearchContextPayload) -> SearchContextPayload:
-    return SearchContextPayload.model_validate(base_context.model_dump())
-
-
-def _apply_follow_up_action(base_context: SearchContextPayload, action: Optional[str]) -> SearchContextPayload:
-    context = _clone_context(base_context)
-    context.context_id = str(uuid.uuid4())
-    context.created_at = time.time()
-    if action == "peer_reviewed_only":
-        context.peer_reviewed = True
-    elif action == "open_access_only":
-        context.open_access = True
-    elif action == "last_5_years":
-        context.year_from = str(CURRENT_YEAR - 4)
-        context.year_to = str(CURRENT_YEAR)
-    elif action == "last_10_years":
-        context.year_from = str(CURRENT_YEAR - 9)
-        context.year_to = str(CURRENT_YEAR)
-    elif action == "books_only":
-        context.resource_type = "books"
-    elif action == "articles_only":
-        context.resource_type = "articles"
-    elif action == "both_resources":
-        context.resource_type = "both"
-    elif action == "search_pubmed":
-        context.source = "pubmed"
-        context.intent = "search_medical"
-        context.resource_type = "articles"
-    elif action == "search_primo":
-        context.source = "primo"
-    return context
-
-
-async def _generate_topic_follow_ups(topic: str, model: str) -> List[dict]:
-    """
-    FIX: Generate 3 topic-specific intellectual follow-up questions using LLM.
-    These are ASPECT-based (related subtopics, methodological angles, applications)
-    not generic filter suggestions like "peer reviewed only".
-    """
-    settings = get_settings()
-    if not settings.openai_api_key:
-        return []
-    try:
-        llm = _get_llm(model, temperature=0.5, max_tokens=200)
-        response = await llm.ainvoke([
-            {"role": "system", "content": (
-                "You are a research librarian helping a user explore a topic more deeply. "
-                "Given a research topic, generate exactly 3 short follow-up questions that explore "
-                "DIFFERENT ASPECTS of the topic — such as subtopics, methodological angles, "
-                "applications, comparisons, or related fields. "
-                "Do NOT suggest filter actions like peer-reviewed, date ranges, or format changes. "
-                "Return ONLY a JSON array of 3 strings, each under 12 words. "
-                "No explanation, no preamble, no markdown.\n"
-                "Example for 'quantum computing':\n"
-                '[\"What are the main hardware approaches in quantum computing?\", '
-                '"How does quantum error correction work?\", '
-                '"Applications of quantum computing in cryptography\"]'
-            )},
-            {"role": "user", "content": f"Topic: {topic}"},
-        ])
-        raw = response.content.strip()
-        if raw.startswith("```"):
-            raw = raw.split("\n", 1)[1].rsplit("```", 1)[0].strip()
-        questions = json.loads(raw)
-        if not isinstance(questions, list):
-            return []
-        return [
-            {"label": q.strip("?") + "?", "question": q.strip("?") + " — find articles", "action": "new_search"}
-            for q in questions[:3]
-            if isinstance(q, str) and q.strip()
-        ]
-    except Exception as e:
-        logger.warning(f"Topic follow-up generation failed: {e}")
-        return []
-
-
 async def _search_follow_up(
     context: SearchContextPayload, model: str, summary_mode: bool = False
 ) -> Tuple[str, List[dict]]:
@@ -1571,20 +647,18 @@ async def _run_search_mode(
     search_results = result.get("results", []) or []
     total = result.get("total", len(search_results))
 
-    answer = _search_answer_intro(context, is_follow_up)
+    answer = _search_trace_block(question, context) + _search_answer_intro(context, is_follow_up)
     if filters:
         answer += f"<br><br><strong>Current filters:</strong> {_escape(filters)}."
     if search_results:
         answer += f"<br><br>I found <strong>{total}</strong> result(s). The top items are shown below."
     else:
-        answer += (
-            "<br><br>I couldn't retrieve matching results right now. "
-            "You can still try the direct library links and AI research tools below."
-        )
+        answer += "<br><br>I didn't find matching results right now, but you can still try the direct discovery links and related tools below."
     if context.intent == "search_medical" and context.source != "pubmed":
         answer += "<br><br>For the strongest medical evidence trail, I also recommend checking <strong>PubMed</strong> or <strong>Embase</strong>."
 
     answer += _source_badge(source_name, source_url)
+    answer += _contact_footer_for_query(question, context)
     sources = []
     for item in search_results[:6]:
         link = item.get("primo_url") or item.get("link")
@@ -1601,6 +675,181 @@ def _sort_and_trim_contexts(contexts: List[SearchContextPayload]) -> List[Search
     return ordered[:5]
 
 
+
+def _find_staff_by_token(token: str) -> Optional[dict]:
+    token = (token or '').lower()
+    for staff in STAFF_DIRECTORY:
+        hay = (staff.get('full_name', '') + ' ' + staff.get('role', '')).lower()
+        if token in hay:
+            return staff
+    return None
+
+
+def _contact_footer_for_query(question: str, context: Optional[SearchContextPayload]) -> str:
+    q = (question or '').lower()
+    specialist = _find_staff_by_token('muna')
+    if any(t in q for t in ['database access', 'proxy', 'full text', 'eresource', 'e-resource', 'remote access', 'access problem']):
+        specialist = _find_staff_by_token('rani')
+    elif any(t in q for t in ['website', 'system', 'technical', 'login issue', 'page not loading']):
+        specialist = _find_staff_by_token('walter')
+    elif context and context.intent == 'search_medical':
+        specialist = _find_staff_by_token('jason')
+    elif context and context.intent in {'search_academic', 'search_medical'}:
+        specialist = _find_staff_by_token('nikesh') if context.intent == 'search_academic' else _find_staff_by_token('jason')
+    footer = (
+        '<br><br><strong>Library contact points</strong><br>'
+        f'General help: <a href="{ASK_LIBRARIAN_URL}" target="_blank">Ask a Librarian</a> · '
+        '<a href="mailto:libse@ku.ac.ae">libse@ku.ac.ae</a>'
+    )
+    if specialist:
+        footer += (
+            f'<br>Relevant contact: <strong>{_escape(specialist.get("full_name", ""))}</strong> — '
+            f'{_escape(specialist.get("role", ""))}<br>'
+            f'<a href="mailto:{_escape(specialist.get("email", ""))}">{_escape(specialist.get("email", ""))}</a>'
+        )
+        phone = specialist.get('phone') or specialist.get('work_phone')
+        if phone:
+            footer += f' · <a href="tel:{_escape(str(phone).replace(" ", ""))}">{_escape(phone)}</a>'
+    return footer
+
+
+def _search_trace_block(question: str, context: SearchContextPayload) -> str:
+    topic = _escape(context.display_topic or context.topic)
+    question_html = _escape(question)
+    primo_boolean = _escape(context.primo_boolean_query or '')
+    found_via = 'I identified the main topic, built a PRIMO search query, and looked for KU-accessible results.'
+    if context.intent == 'search_medical':
+        found_via += ' Because this is a medical topic, PubMed is also recommended for broader evidence searching.'
+    block = (
+        f'<div style="margin:10px 0 14px 0;padding:12px 14px;border:1px solid #dbe4ff;border-radius:12px;background:#f8fbff">'
+        f'<strong>Your question:</strong> {question_html}<br>'
+        f'<strong>Interpreted topic:</strong> {topic}<br>'
+    )
+    if primo_boolean:
+        block += f'<strong>PRIMO query used:</strong> <code>{primo_boolean}</code><br>'
+    block += f'<strong>How I found this:</strong> {found_via}</div>'
+    return block
+
+
+def _is_database_recommendation_question(question: str) -> bool:
+    return bool(DATABASE_RECOMMEND_RE.search(question or ''))
+
+
+def _database_recommendation_answer(question: str) -> str:
+    q = (question or '').lower()
+    topic = _escape(_strip_resource_noise(question))
+    dbs = []
+    if any(t in q for t in ['computer science', 'artificial intelligence', 'machine learning', ' ai ', 'cybersecurity']):
+        dbs = [
+            ('ACM Digital Library', 'https://khalifa.idm.oclc.org/login?url=https://dl.acm.org', 'Core computer science literature.'),
+            ('IEEE Xplore', 'https://khalifa.idm.oclc.org/login?url=https://ieeexplore.ieee.org', 'Strong for AI, systems, and engineering computing.'),
+            ('Scopus', 'https://khalifa.idm.oclc.org/login?url=https://www.scopus.com', 'Broad discovery and citation tracking.'),
+        ]
+    elif any(t in q for t in ['medical', 'health', 'nursing', 'clinical', 'biomedical']):
+        dbs = [
+            ('PubMed@KU', 'http://www.ncbi.nlm.nih.gov/pubmed/?otool=iaekustlib', 'Core biomedical literature with KU full-text links.'),
+            ('Embase', 'https://khalifa.idm.oclc.org/login?url=https://www.embase.com', 'Biomedical and pharmacological literature.'),
+            ('CINAHL Ultimate', 'https://khalifa.idm.oclc.org/login?url=https://search.ebscohost.com/login.aspx?authtype=ip,uid&profile=ehost&defaultdb=cul', 'Nursing and allied health literature.'),
+        ]
+    elif any(t in q for t in ['civil']):
+        dbs = [
+            ('ASCE Library', 'https://khalifa.idm.oclc.org/login?url=https://ascelibrary.org', 'Core civil engineering journals and conference papers.'),
+            ('ScienceDirect', 'https://khalifa.idm.oclc.org/login?url=https://www.sciencedirect.com', 'Strong full text across civil engineering topics.'),
+            ('Scopus', 'https://khalifa.idm.oclc.org/login?url=https://www.scopus.com', 'Discovery and citation tracking.'),
+        ]
+    elif any(t in q for t in ['mechanical']):
+        dbs = [
+            ('ASME Digital Library', 'https://khalifa.idm.oclc.org/login?url=https://asmedigitalcollection.asme.org', 'Core mechanical engineering literature.'),
+            ('Knovel', 'https://khalifa.idm.oclc.org/login?url=https://app.knovel.com/kn', 'Engineering reference books and data.'),
+            ('ScienceDirect', 'https://khalifa.idm.oclc.org/login?url=https://www.sciencedirect.com', 'Broad full text.'),
+        ]
+    elif any(t in q for t in ['electrical']):
+        dbs = [
+            ('IEEE Xplore', 'https://khalifa.idm.oclc.org/login?url=https://ieeexplore.ieee.org/Xplore/dynhome.jsp', 'Core electrical engineering database.'),
+            ('INSPEC', 'https://khalifa.idm.oclc.org/login?url=https://www.theiet.org/publishing/inspec', 'Strong indexing for EE and electronics.'),
+            ('Scopus', 'https://khalifa.idm.oclc.org/login?url=https://www.scopus.com', 'Discovery and citation tracking.'),
+        ]
+    else:
+        dbs = [
+            ('PRIMO', 'https://khalifa.primo.exlibrisgroup.com/discovery/search?vid=971KUOSTAR_INST:KU', 'Best starting point for KU-accessible books, articles, and journals.'),
+            ('Scopus', 'https://khalifa.idm.oclc.org/login?url=https://www.scopus.com', 'Broad multidisciplinary discovery.'),
+            ('Web of Science', 'https://khalifa.idm.oclc.org/login?url=https://www.webofscience.com', 'Broad multidisciplinary citation searching.'),
+        ]
+    answer = f'<strong>Best databases for {topic}</strong><br><br>'
+    answer += 'Here are strong starting points for this subject:<br>'
+    for name, url, why in dbs:
+        answer += f'<br>• <a href="{url}" target="_blank"><strong>{name}</strong></a> — {_escape(why)}'
+    answer += '<br><br>If you want, I can also turn this into a direct article search.'
+    return answer
+
+
+def _database_guidance_for_topic(context: SearchContextPayload) -> str:
+    topic = _escape(context.display_topic or context.topic)
+    return f'For deeper research on <strong>{topic}</strong>, the recommended AI research tools are listed at the end of this answer.'
+
+
+async def _generate_topic_follow_ups(topic: str, model: str) -> List[dict]:
+    settings = get_settings()
+    if not settings.openai_api_key:
+        return []
+    try:
+        llm = _get_llm(model, temperature=0.4, max_tokens=200)
+        response = await llm.ainvoke([
+            {"role": "system", "content": "Generate exactly 3 short follow-up questions exploring different angles of the topic. Return only a JSON array of strings."},
+            {"role": "user", "content": f"Topic: {topic}"},
+        ])
+        raw = response.content.strip()
+        if raw.startswith('```'):
+            raw = raw.split('\\n', 1)[1].rsplit('```', 1)[0].strip()
+        questions = json.loads(raw)
+        if not isinstance(questions, list):
+            return []
+        suggestions: List[dict] = []
+        for q in questions[:3]:
+            if not isinstance(q, str) or not q.strip():
+                continue
+            q_clean = _normalize_whitespace(q.strip().rstrip('?'))
+            contextual = q_clean if topic.lower() in q_clean.lower() else f'{q_clean} for {topic}'
+            suggestions.append({'label': q_clean + '?', 'question': f'Find research articles on {contextual}', 'action': None})
+        return suggestions
+    except Exception as e:
+        logger.warning(f'Topic follow-up generation failed: {e}')
+        return []
+
+
+async def _research_snapshot(context: SearchContextPayload, model: str) -> Tuple[str, List[dict], List[dict]]:
+    topic = context.topic
+    papers = await _semantic_scholar_search(topic, limit=8)
+    references: List[dict] = []
+    primo_result, primo_url = await _search_primo_catalog(context, limit=6)
+    search_results = primo_result.get('results', []) or []
+    answer = _search_trace_block(context.ai_tool_query or f'Research on {topic}', context)
+    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}'
+        if search_results:
+            answer += '<br><br><strong>KU Library starting points:</strong> I also found KU-accessible results below so you can continue with subscribed material.'
+        answer += '<br><br><strong>Selected references:</strong><br>'
+        for i, paper in enumerate(papers[:6], 1):
+            answer += f'<br><strong>[{i}]</strong> <a href="{paper["link"]}" target="_blank" style="color:#003366;font-weight:600">{_escape(paper["title"])}</a><br><span style="font-size:.8rem;color:#6b7280">{_escape(paper["authors"])} · {paper["year"]} · {_escape(paper["venue"] or "")}</span>'
+        answer += '<br><br>For deeper research, the recommended AI research tools are listed at the end of this answer.'
+        answer += _source_badge('semantic', 'https://www.semanticscholar.org/')
+        if search_results:
+            answer += _source_badge('primo', primo_url)
+        answer += _contact_footer_for_query(topic, context)
+        references = [{'title': p['title'], 'url': p['link']} for p in papers[:6]]
+        return answer, search_results, references
+    if search_results:
+        answer += f'<strong>📚 KU Library starting points on {_escape(topic)}</strong><br><br>I found KU-accessible library results you can open immediately below.<br><br>For deeper research, the recommended AI research tools are listed at the end of this answer.'
+    else:
+        answer += f'<strong>📚 Research starting points on {_escape(topic)}</strong><br><br>I found direct library discovery routes you can use to continue this search.<br><br>For deeper research, the recommended AI research tools are listed at the end of this answer.'
+    answer += _source_badge('primo', primo_url)
+    answer += _contact_footer_for_query(topic, context)
+    return answer, search_results, []
+
 # ── Main Endpoint ──────────────────────────────────────────────────────────────
 
 @router.post("", response_model=AgentResponse)
@@ -1705,22 +954,6 @@ async def agent_query(request: Request, req: AgentRequest):
             follow_up_suggestions=follow_up_suggestions,
         )
 
-    if _looks_database_recommendation_question(question):
-        follow_up_question = "Would you like me to search one of these databases for you next?"
-        follow_up_suggestions = [
-            {"label": "Search PRIMO on this topic", "question": question.replace("best databases", "find articles").replace("which database should I use for", "find articles on")},
-            {"label": "Show off-campus access help", "question": "How do I access databases off campus?"},
-        ]
-        return AgentResponse(
-            answer=_database_recommendation_answer(question),
-            intent="library_info",
-            tools_used=["database_recommendation"],
-            model_used=model,
-            response_time=time.time() - start_time,
-            follow_up_question=follow_up_question,
-            follow_up_suggestions=follow_up_suggestions,
-        )
-
     is_follow_up, follow_up_action, base_context = _detect_follow_up(question, client_state)
 
     if is_follow_up and base_context:
@@ -1732,7 +965,7 @@ async def agent_query(request: Request, req: AgentRequest):
             if follow_up_action == "summarize_topic":
                 answer, search_results, sources = await _research_snapshot(context, model)
             elif follow_up_action == "best_databases":
-                answer = _database_recommendation_answer(context.display_topic or context.topic)
+                answer = _database_recommendation_answer(context.topic) + _contact_footer_for_query(question, context) + _source_badge("ku_library", "https://library.ku.ac.ae/eresources")
                 search_results = []
                 sources = []
             else:
@@ -1740,6 +973,7 @@ async def agent_query(request: Request, req: AgentRequest):
                     f"<strong>Research guide for {_escape(context.display_topic or context.topic)}</strong><br><br>"
                     f"{_database_guidance_for_topic(context)}"
                     + _source_badge("libbee")
+                    + _contact_footer_for_query(question, context)
                 )
                 search_results = []
                 sources = []
@@ -1805,6 +1039,21 @@ async def agent_query(request: Request, req: AgentRequest):
             follow_up_suggestions=follow_up_suggestions,
         )
 
+    if _is_database_recommendation_question(question):
+        answer = _database_recommendation_answer(question)
+        answer += _contact_footer_for_query(question, None)
+        answer += _source_badge("ku_library", "https://library.ku.ac.ae/eresources")
+        follow_up_question, follow_up_suggestions = _library_follow_up(question)
+        return AgentResponse(
+            answer=answer,
+            intent="library_info",
+            tools_used=["database_recommendation"],
+            model_used=model,
+            response_time=time.time() - start_time,
+            follow_up_question=follow_up_question,
+            follow_up_suggestions=follow_up_suggestions,
+        )
+
     if intent == "library_info":
         try:
             from app import rag_service
@@ -1868,8 +1117,10 @@ async def agent_query(request: Request, req: AgentRequest):
 
         if summary_mode or deep_research_mode:
             answer, search_results, sources = await _research_snapshot(context, model)
+            answer = _search_trace_block(question, context) + answer
             if deep_research_mode and "Research guide" not in answer:
-                answer += f"<br><br><strong>Research guide:</strong> {_database_guidance_for_topic(context)}"
+                answer += "<br><br><em>For deeper research, recommended AI research tools are listed at the end of this answer.</em>"
+            answer += _contact_footer_for_query(question, context)
             follow_up_question, follow_up_suggestions = await _search_follow_up(context, model, summary_mode=True)
             _safe_metrics_increment("search_handoffs")
             return AgentResponse(

src/api/search.py

@@ -8,7 +8,7 @@ Key fixes:
 - query sent to both APIs is clean topic keywords only — no rtype noise
 """
 import logging
-from typing import Optional
+from typing import Optional, List
 from urllib.parse import quote
 
 import httpx
@@ -94,38 +94,69 @@ async def search_endpoint(req: SearchRequest):
     return await search_scholar(req)
 
 
-def _build_exact_primo_url(doc: dict, query_encoded: str) -> str:
+# ── PRIMO ──────────────────────────────────────────────────────────────────────
+
+# ── PRIMO helpers ───────────────────────────────────────────────────────────────
+
+def _first_str(value):
+    if isinstance(value, list) and value:
+        return value[0]
+    if isinstance(value, str):
+        return value
+    return ""
+
+
+def _extract_primo_docid(doc: dict) -> str:
     pnx = doc.get("pnx", {}) or {}
     control = pnx.get("control", {}) or {}
-    search = pnx.get("search", {}) or {}
-    recordid = ""
-    for candidate in [
-        control.get("recordid"),
-        control.get("sourcerecordid"),
-        search.get("recordid"),
-        search.get("addsrcrecordid"),
-    ]:
-        if isinstance(candidate, list) and candidate:
-            recordid = str(candidate[0]).strip()
-            if recordid:
-                break
-        elif isinstance(candidate, str) and candidate.strip():
-            recordid = candidate.strip()
-            break
-    if recordid:
+    search_sec = pnx.get("search", {}) or {}
+    candidates: List[str] = [
+        _first_str(control.get("recordid")),
+        _first_str(control.get("sourcerecordid")),
+        _first_str(search_sec.get("recordid")),
+        _first_str(search_sec.get("addsrcrecordid")),
+    ]
+    for key in ("recordid", "pnxId", "id"):
+        val = doc.get(key)
+        if isinstance(val, str):
+            candidates.append(val)
+        elif isinstance(val, list) and val:
+            candidates.append(val[0])
+    for cand in candidates:
+        cand = (cand or "").strip()
+        if cand:
+            return cand
+    return ""
+
+
+def _primo_record_url(doc: dict, query_encoded: str) -> str:
+    delivery = doc.get("delivery", {}) or {}
+    bestlocation = delivery.get("bestlocation", {}) or {}
+    for key in ("link", "url"):
+        val = bestlocation.get(key)
+        if isinstance(val, str) and "fulldisplay" in val:
+            return val
+    links = delivery.get("links", []) or []
+    for link_obj in links:
+        if isinstance(link_obj, dict):
+            val = link_obj.get("link") or link_obj.get("url") or ""
+            if isinstance(val, str) and "fulldisplay" in val:
+                return val
+    docid = _extract_primo_docid(doc)
+    if docid:
+        pnx = doc.get("pnx", {}) or {}
+        control = pnx.get("control", {}) or {}
+        sourceid = _first_str(control.get("sourceid")).lower()
+        context = "PC" if docid.lower().startswith("cdi_") or "central" in sourceid else "L"
         return (
             "https://khalifa.primo.exlibrisgroup.com/discovery/fulldisplay"
-            f"?docid={quote(recordid)}&context=L&vid=971KUOSTAR_INST:KU&lang=en"
-            f"&search_scope=MyInst_and_CI&tab=Everything&query=any,contains,{query_encoded}&offset=0"
+            f"?docid={quote(docid)}&context={context}&vid=971KUOSTAR_INST:KU&lang=en&search_scope=MyInst_and_CI&tab=Everything"
         )
     return (
-        f"https://khalifa.primo.exlibrisgroup.com/discovery/search"
-        f"?query=any,contains,{query_encoded}&vid=971KUOSTAR_INST:KU"
+        "https://khalifa.primo.exlibrisgroup.com/discovery/search"
+        f"?query=any,contains,{query_encoded}&vid=971KUOSTAR_INST:KU&lang=en&search_scope=MyInst_and_CI&tab=Everything"
     )
 
-
-# ── PRIMO ──────────────────────────────────────────────────────────────────────
-
 async def search_primo(req: SearchRequest, api_key: str):
     """
     Send clean topic keywords to q=any,contains.
@@ -208,7 +239,7 @@ async def search_primo(req: SearchRequest, api_key: str):
                     "date": (d.get("date") or [""])[0],
                     "type": (d.get("type") or [""])[0],
                     "source": (d.get("source") or [""])[0],
-                    "primo_url": _build_exact_primo_url(doc, query_encoded),
+                    "primo_url": _primo_record_url(doc, query_encoded),
                     "_source": "PRIMO",
                 })
             return {