Upload 2 files

src/api/agent.py

@@ -726,20 +726,23 @@ def _parse_year_filters(question: str) -> Tuple[Optional[str], Optional[str]]:
 
 
 def _make_primo_boolean_query(context: SearchContextPayload) -> str:
+    """Build synonym-aware PRIMO boolean using shared planner logic."""
     topic = _title_case_topic(context.display_topic or context.topic)
-    topic = _strip_resource_noise(topic) or (context.topic or "library search")
-    return _shared_build_primo_boolean_query(topic)
+    topic = _strip_resource_noise(topic)
+    if not topic:
+        topic = context.topic or "library search"
+    return build_boolean_query(topic)
 
 
 def _primo_clean_url(context: SearchContextPayload) -> str:
     boolean_query = context.primo_boolean_query or _make_primo_boolean_query(context)
-    return _shared_build_primo_discovery_url(
+    return build_primo_discovery_url(
         boolean_query,
-        resource_type=context.resource_type,
-        peer_reviewed=context.peer_reviewed,
-        open_access=context.open_access,
-        year_from=context.year_from,
-        year_to=context.year_to,
+        context.resource_type,
+        context.peer_reviewed,
+        context.open_access,
+        context.year_from,
+        context.year_to,
     )
 
 
@@ -960,12 +963,8 @@ def _extractive_snapshot_from_papers(topic: str, papers: List[dict]) -> str:
 # ── PRIMO / PubMed Search Wrappers ────────────────────────────────────────────
 
 from src.api.search import (
-    SearchRequest,
-    build_primo_boolean_query as _shared_build_primo_boolean_query,
-    build_primo_discovery_url as _shared_build_primo_discovery_url,
-    build_pubmed_url as _shared_build_pubmed_url,
-    search_primo,
-    search_pubmed,
+    SearchRequest, search_primo, search_pubmed,
+    build_boolean_query, build_primo_discovery_url, build_pubmed_url,
 )
 
 
@@ -989,7 +988,8 @@ async def _search_primo_catalog(context: SearchContextPayload, limit: int = 5) -
             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
+            resource_type=context.resource_type,
+            boolean_query=context.primo_boolean_query,
         ),
         settings.primo_api_key,
     )
@@ -998,6 +998,9 @@ async def _search_primo_catalog(context: SearchContextPayload, limit: int = 5) -
 
 
 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
@@ -1008,11 +1011,11 @@ async def _search_pubmed_articles(context: SearchContextPayload, limit: int = 5)
             source="pubmed",
             limit=limit,
             peer_reviewed=context.peer_reviewed,
-            year_from=context.year_from,
-            year_to=context.year_to,
+            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 = _shared_build_pubmed_url(clean_topic, context.year_from, context.year_to, context.peer_reviewed)
+    pubmed_url = build_pubmed_url(clean_topic, context.year_from, context.year_to)
     return result, pubmed_url
 
 
@@ -1020,24 +1023,22 @@ async def _search_pubmed_articles(context: SearchContextPayload, limit: int = 5)
 
 def _tool_urls(context: SearchContextPayload) -> Dict[str, str]:
     ai_query = quote(context.ai_tool_query or context.display_topic or context.topic)
-    primo_ai_query = quote(context.ai_tool_query or context.display_topic or context.topic)
-    urls = {
+    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}",
         "ebsco_ai": f"https://research-ebsco-com.khalifa.idm.oclc.org/c/ntdlkp/search?q={ai_query}",
-        "primo_ai": f"{PRIMO_AI_URL}{primo_ai_query}",
+        "primo_ai": f"{PRIMO_AI_URL}{ai_query}",
         "consensus": f"https://consensus.app/results/?q={ai_query}",
         "primo_discovery": _primo_clean_url(context),
+        "pubmed": build_pubmed_url(clean_topic, context.year_from, context.year_to) if context.intent == "search_medical" else "",
     }
-    if context.intent == "search_medical":
-        urls["pubmed"] = _shared_build_pubmed_url(context.topic, context.year_from, context.year_to, context.peer_reviewed)
-    return urls
 
 
 def _database_guidance_for_topic(context: SearchContextPayload) -> str:
     topic = _escape(context.display_topic or context.topic)
     urls = _tool_urls(context)
-    ai_tools = (
+    ai_links = (
         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["ebsco_ai"]}" target="_blank" style="color:#9d174d;font-weight:700;text-decoration:none">EBSCO AI</a> · '
@@ -1045,18 +1046,76 @@ def _database_guidance_for_topic(context: SearchContextPayload) -> str:
         f'<a href="{urls["consensus"]}" target="_blank" style="color:#86198f;font-weight:700;text-decoration:none">Consensus</a>'
     )
     more_results = f'<a href="{urls["primo_discovery"]}" target="_blank" style="color:#5b21b6;font-weight:700;text-decoration:none">PRIMO Library Discovery</a>'
-    if context.intent == "search_medical" and urls.get("pubmed"):
+    if context.intent == "search_medical" and urls["pubmed"]:
         more_results += f' · <a href="{urls["pubmed"]}" target="_blank" style="color:#065f46;font-weight:700;text-decoration:none">PubMed</a>'
-        return (
-            f"For deeper work on <strong>{topic}</strong>, continue with these AI research tools: {ai_tools}. "
-            f"For more results, use {more_results}. Medical topics are strongest in PubMed, Embase, and CINAHL."
-        )
     return (
-        f"For deeper work on <strong>{topic}</strong>, continue with these AI research tools: {ai_tools}. "
-        f"For more results, use {more_results}."
+        f'<strong>AI tools:</strong> {ai_links}<br>'
+        f'<strong>More results:</strong> {more_results}'
+    )
+
+
+
+
+GENERAL_CONTACT_HTML = (
+    'General queries: <a href="https://library.ku.ac.ae/AskUs" target="_blank">Ask a Librarian</a> '
+    '· <a href="mailto:libse@ku.ac.ae">libse@ku.ac.ae</a>'
+)
+
+
+def _contact_footer(question: str, intent: str, context: Optional[SearchContextPayload] = None) -> str:
+    q = (question or "").lower()
+    lines = [GENERAL_CONTACT_HTML]
+    # Public services for general library help
+    if intent == "library_info":
+        lines.append('Public services: Muna Al Blooshi · <a href="mailto:muna.alblooshi@ku.ac.ae">muna.alblooshi@ku.ac.ae</a> · +971 2 312 4212')
+    # E-resources contact for access/search/database/full-text issues
+    if intent in {"search_academic", "search_medical"} or any(t in q for t in ["database", "e-resource", "eresource", "access", "full text", "proxy", "login", "remote access", "primo", "pubmed"]):
+        lines.append('E-resources: Rani Anand · <a href="mailto:rani.anand@ku.ac.ae">rani.anand@ku.ac.ae</a> · +971 2 312 3935')
+    # Research support for scholarly/research questions
+    if intent in {"search_academic", "search_medical"} or any(t in q for t in ["research", "literature review", "citation", "orcid", "open access", "refworks", "bibliometrics"]):
+        lines.append('Research support: Nikesh Narayanan · <a href="mailto:nikesh.narayanan@ku.ac.ae">nikesh.narayanan@ku.ac.ae</a> · +971 2 312 3980')
+    # Systems / technology contact
+    if any(t in q for t in ["system", "systems", "website", "technology", "technical", "error", "broken"]):
+        lines.append('Systems: Walter Brian Hall · <a href="mailto:walter.hall@ku.ac.ae">walter.hall@ku.ac.ae</a> · +971 2 312 3163')
+    dedup = []
+    seen = set()
+    for line in lines:
+        if line not in seen:
+            seen.add(line)
+            dedup.append(line)
+    html_lines = ''.join(f'<div>{line}</div>' for line in dedup)
+    return (
+        '<div style="margin-top:12px;padding:10px 12px;background:#f8fafc;border:1px solid #dbeafe;border-radius:10px;font-size:.8rem;color:#1e3a8a">'
+        '<strong>Library contact points</strong>' + html_lines + '</div>'
     )
 
 
+def _scholarly_trace_html(question: str, context: SearchContextPayload, mode: str) -> str:
+    topic = _escape(context.display_topic or context.topic)
+    ai_query = _escape(context.ai_tool_query or question)
+    primo_boolean = _escape(context.primo_boolean_query or _make_primo_boolean_query(context))
+    retrieval = (
+        'I corrected and normalized your question, extracted the main topic, expanded close synonyms with OR, connected concept groups with AND, '
+        'then searched Semantic Scholar for scholarly evidence and PRIMO for KU-accessible results.'
+        if mode == 'snapshot' else
+        'I corrected and normalized your question, extracted the main topic, expanded close synonyms with OR, connected concept groups with AND, '
+        f'then searched {"PubMed" if context.source == "pubmed" else "PRIMO Library Discovery"} using cleaned topic terms plus the active filters.'
+    )
+    extra = ''
+    if context.intent == 'search_medical':
+        extra = f'<div><strong>PubMed search link:</strong> <a href="{build_pubmed_url(context.topic, context.year_from, context.year_to)}" target="_blank">Open PubMed for this topic</a></div>'
+    return (
+        '<div style="margin:0 0 10px 0;padding:10px 12px;background:#f8fafc;border:1px solid #d1d5db;border-radius:10px;font-size:.8rem;color:#334155">'
+        '<div style="font-weight:700;color:#003366;margin-bottom:6px">Search strategy used</div>'
+        f'<div><strong>Your question:</strong> {_escape(question)}</div>'
+        f'<div><strong>Interpreted topic:</strong> {topic}</div>'
+        f'<div><strong>PRIMO Library Discovery query:</strong> <code>{primo_boolean}</code></div>'
+        f'<div><strong>AI tools query:</strong> {_escape(ai_query)}</div>'
+        f'{extra}'
+        f'<div><strong>How I found this answer:</strong> {retrieval}</div>'
+        '</div>'
+    )
+
 # ── Research Snapshot ─────────────────────────────────────────────────────────
 
 async def _research_snapshot(context: SearchContextPayload, model: str) -> Tuple[str, List[dict], List[dict]]:
@@ -1096,6 +1155,7 @@ async def _research_snapshot(context: SearchContextPayload, model: str) -> Tuple
         answer += _source_badge("semantic", "https://www.semanticscholar.org/")
         if search_results:
             answer += _source_badge("primo", primo_url)
+        answer = _scholarly_trace_html(topic, context, "snapshot") + answer + "<br><br>" + _database_guidance_for_topic(context) + _contact_footer(topic, context.intent, context)
         references = [{"title": p["title"], "url": p["link"]} for p in papers[:6]]
         return answer, search_results, references
 
@@ -1111,6 +1171,7 @@ async def _research_snapshot(context: SearchContextPayload, model: str) -> Tuple
             f"<strong>AI sources:</strong> {_database_guidance_for_topic(context)}"
         )
     answer += _source_badge("primo", primo_url)
+    answer = _scholarly_trace_html(topic, context, "snapshot") + answer + "<br><br>" + _contact_footer(topic, context.intent, context)
     return answer, search_results, []
 
 
@@ -1201,6 +1262,8 @@ def _detect_follow_up(question: str, client_state: Optional[ClientStatePayload])
         return False, None, None
     explicit_action = (client_state.follow_up_action if client_state else None) or None
     if explicit_action:
+        if explicit_action == "new_search":
+            return False, None, None
         return True, explicit_action, base_context
     action = _parse_refinement_action(question)
     if not action:
@@ -1437,7 +1500,7 @@ 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 = _scholarly_trace_html(question, context, "search") + _search_answer_intro(context, is_follow_up)
     if filters:
         answer += f"<br><br><strong>Current filters:</strong> {_escape(filters)}."
     if search_results:
@@ -1450,7 +1513,9 @@ async def _run_search_mode(
     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 += "<br><br>" + _database_guidance_for_topic(context)
     answer += _source_badge(source_name, source_url)
+    answer += _contact_footer(question, context.intent, context)
     sources = []
     for item in search_results[:6]:
         link = item.get("primo_url") or item.get("link")
@@ -1548,7 +1613,7 @@ async def agent_query(request: Request, req: AgentRequest):
     if _looks_library_hours_question(question):
         follow_up_question, follow_up_suggestions = _library_follow_up(question)
         return AgentResponse(
-            answer=_hours_answer() + _source_badge("ku_library", LIBRARY_HOURS_URL),
+            answer=_hours_answer() + _source_badge("ku_library", LIBRARY_HOURS_URL) + _contact_footer(question, "library_info"),
             intent="library_info",
             tools_used=["hours_hardcoded"],
             ask_librarian=False,
@@ -1561,7 +1626,7 @@ async def agent_query(request: Request, req: AgentRequest):
     if _looks_campus_question(question):
         follow_up_question, follow_up_suggestions = _library_follow_up(question)
         return AgentResponse(
-            answer=_campus_answer() + _source_badge("ku_library", "https://library.ku.ac.ae/"),
+            answer=_campus_answer() + _source_badge("ku_library", "https://library.ku.ac.ae/") + _contact_footer(question, "library_info"),
             intent="library_info",
             tools_used=["campus_hardcoded"],
             ask_librarian=False,
@@ -1671,11 +1736,13 @@ async def agent_query(request: Request, req: AgentRequest):
                 f'🔗 <a href="{ASK_LIBRARIAN_URL}" target="_blank">Ask a Librarian</a>'
             )
             answer += _source_badge("ku_library", ASK_LIBRARIAN_URL)
+            answer += _contact_footer(question, "library_info")
             sources = []
             tools_used = ["rag_no_results"]
         else:
             answer = await _rag_answer(question, rag_results, history, model)
             answer += _source_badge("rag", "https://library.ku.ac.ae/")
+            answer += _contact_footer(question, "library_info")
             sources = [{"title": r.get("title", "Library KB"), "url": r.get("source", "")} for r in rag_results if r.get("source")]
             tools_used = ["rag_hybrid_search"]
 
@@ -1718,8 +1785,6 @@ async def agent_query(request: Request, req: AgentRequest):
 
         if summary_mode or deep_research_mode:
             answer, search_results, sources = await _research_snapshot(context, model)
-            if deep_research_mode and "Research guide" not in answer:
-                answer += f"<br><br><strong>Research guide:</strong> {_database_guidance_for_topic(context)}"
             follow_up_question, follow_up_suggestions = await _search_follow_up(context, model, summary_mode=True)
             _safe_metrics_increment("search_handoffs")
             return AgentResponse(

src/api/search.py

@@ -1,6 +1,6 @@
 import logging
 import re
-from typing import Dict, List, Optional
+from typing import Optional, List, Dict
 from urllib.parse import quote
 
 import httpx
@@ -12,90 +12,68 @@ from src.config import get_settings
 logger = logging.getLogger(__name__)
 router = APIRouter()
 
-PRIMO_BASE = "https://khalifa.primo.exlibrisgroup.com/discovery/search?vid=971KUOSTAR_INST:KU"
-PRIMO_AI_BASE = "https://khalifa.primo.exlibrisgroup.com/discovery/researchAssistant?vid=971KUOSTAR_INST:KU&query="
-EBSCO_AI_BASE = "https://research-ebsco-com.khalifa.idm.oclc.org/c/ntdlkp/search?q="
-SCOPUS_AI_BASE = "https://www-scopus-com.khalifa.idm.oclc.org/pages/ai?query="
-LEAPSPACE_BASE = "https://www.sciencedirect.com/leapspace?query="
-CONSENSUS_BASE = "https://consensus.app/results/?q="
-CURRENT_YEAR = 2026
-
-PREFIX_PATTERNS = [
-    r"^summari[sz]e\s+the\s+latest\s+studies\s+in\s+",
-    r"^summari[sz]e\s+the\s+latest\s+research\s+on\s+",
-    r"^summari[sz]e\s+recent\s+studies\s+in\s+",
-    r"^summari[sz]e\s+recent\s+research\s+on\s+",
-    r"^give\s+me\s+a\s+summary\s+of\s+",
-    r"^give\s+me\s+an\s+overview\s+of\s+",
-    r"^give\s+me\s+a\s+brief\s+overview\s+of\s+",
-    r"^find\s+(?:peer[- ]reviewed\s+)?articles?\s+on\s+",
-    r"^find\s+(?:peer[- ]reviewed\s+)?papers?\s+on\s+",
-    r"^find\s+books?\s+on\s+",
-    r"^search\s+for\s+articles?\s+on\s+",
-    r"^search\s+for\s+papers?\s+on\s+",
-    r"^i\s+need\s+(?:peer[- ]reviewed\s+)?articles?\s+on\s+",
-    r"^i\s+need\s+papers?\s+on\s+",
-    r"^i\s+need\s+books?\s+on\s+",
-    r"^show\s+me\s+articles?\s+on\s+",
-    r"^get\s+me\s+articles?\s+on\s+",
-    r"^tell\s+me\s+about\s+",
-    r"^explain\s+",
-    r"^overview\s+of\s+",
-    r"^summary\s+of\s+",
-    r"^latest\s+studies\s+in\s+",
-    r"^latest\s+research\s+on\s+",
-    r"^recent\s+research\s+on\s+",
-    r"^recent\s+studies\s+in\s+",
-]
+PRIMO_BASE_URL = "https://khalifa.primo.exlibrisgroup.com/discovery/search?vid=971KUOSTAR_INST:KU"
+PRIMO_AI_URL = "https://khalifa.primo.exlibrisgroup.com/discovery/researchAssistant?vid=971KUOSTAR_INST:KU&query="
 
-RESOURCE_NOISE_RE = re.compile(
+_RESOURCE_NOISE_RE = re.compile(
     r"\b(articles?|papers?|books?|ebooks?|journals?|publications?|monographs?"
-    r"|peer[- ]reviewed|open[- ]access|studies|study|research|latest|recent)\b",
+    r"|peer[- ]reviewed|open[- ]access|studies|study|research|latest|recent|current"
+    r"|summary|summarize|summarise|overview|brief|analysis|review|deep|dive)\b",
     re.IGNORECASE,
 )
 
-STOP_WORDS = {
-    "the", "a", "an", "and", "or", "of", "on", "in", "for", "to", "with", "by",
-    "from", "at", "about", "latest", "recent", "current", "summary", "overview", "brief",
-    "analysis", "review", "deep", "find", "search", "show", "give", "me", "need", "please",
-}
+_MEDICAL_HINT_RE = re.compile(
+    r"\b(pubmed|embase|cinahl|clinicalkey|cochrane|uptodate|medline|medicine|medical|health|clinical|nursing|pharmacy|biomedical|disease|therapy|treatment|diagnosis|patient|cancer|diabetes|epidemiology|oncology|cardiology)\b",
+    re.IGNORECASE,
+)
 
-PHRASE_SYNONYMS: Dict[str, List[str]] = {
-    "global warming": ["climate change"],
-    "climate change": ["global warming"],
-    "machine learning": ["artificial intelligence", "AI"],
-    "artificial intelligence": ["AI", "machine learning"],
-    "deep learning": ["neural networks"],
-    "renewable energy": ["clean energy", "sustainable energy"],
-    "energy transition": ["decarbonization"],
-    "cyber security": ["cybersecurity", "information security"],
-    "cybersecurity": ["cyber security", "information security"],
-    "public health": ["population health"],
-    "gene editing": ["CRISPR"],
-    "mental health": ["psychological health"],
-    "higher education": ["tertiary education", "universities"],
-}
+_PREFIXES = [
+    "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 ",
+    "give me a summary of ", "give me an overview of ", "give me a brief on ",
+    "give me articles on ", "peer reviewed papers on ", "peer-reviewed papers on ", "peer reviewed articles on ", "peer-reviewed articles on ",
+    "find peer reviewed articles on ", "find peer-reviewed articles on ",
+    "find articles on ", "find papers on ", "find books on ",
+    "search for articles on ", "search for papers on ", "look for articles on ",
+    "i need articles on ", "i need books on ", "research on ", "literature on ",
+    "tell me about ", "explain ", "what is ", "what are ",
+]
+
+PHRASE_SYNONYMS: List[tuple[str, List[str]]] = [
+    ("global warming", ["climate change"]),
+    ("climate change", ["global warming"]),
+    ("machine learning", ["artificial intelligence", "AI"]),
+    ("artificial intelligence", ["AI", "machine learning"]),
+    ("higher education", ["universities", "tertiary education"]),
+    ("university libraries", ["academic libraries", "academic library"]),
+    ("university library", ["academic library"]),
+    ("renewable energy", ["sustainable energy", "clean energy"]),
+    ("solar energy", ["solar power", "photovoltaics"]),
+    ("cyber security", ["cybersecurity", "information security"]),
+    ("internet of things", ["IoT"]),
+    ("big data", ["data analytics"]),
+    ("public health", ["population health"]),
+    ("gene editing", ["CRISPR", "genome editing"]),
+    ("mental health", ["psychological wellbeing", "wellbeing"]),
+    ("supply chain", ["logistics"]),
+    ("academic writing", ["scholarly writing"]),
+]
 
 TOKEN_SYNONYMS: Dict[str, List[str]] = {
     "healthcare": ["medicine", "clinical"],
-    "medical": ["clinical", "medicine"],
-    "nursing": ["clinical", "patient care"],
+    "agriculture": ["farming"],
     "education": ["teaching", "learning"],
-    "students": ["student"],
     "student": ["students"],
+    "students": ["student"],
+    "library": ["libraries"],
+    "libraries": ["library"],
+    "energy": ["power"],
     "sustainability": ["sustainable development"],
-    "cancer": ["oncology"],
-    "heart": ["cardiovascular"],
-    "brain": ["neurology", "neuroscience"],
-    "politics": ["political"],
-    "engineering": ["engineer*"],
+    "older": ["aging"],
 }
 
-MEDICAL_HINT_RE = re.compile(
-    r"\b(medicine|medical|health|clinical|nursing|pharmacy|biomedical|pubmed|embase|cinahl|cochrane|uptodate|disease|therapy|treatment|diagnosis|patient|hospital|cancer|diabetes)\b",
-    re.IGNORECASE,
-)
-
 
 class SearchRequest(BaseModel):
     query: str
@@ -136,8 +114,9 @@ class SearchRequest(BaseModel):
     @field_validator("resource_type")
     @classmethod
     def valid_resource_type(cls, v: str) -> str:
-        allowed = {"articles", "books", "both"}
-        return v if v in allowed else "articles"
+        if v not in {"articles", "books", "both"}:
+            return "articles"
+        return v
 
 
 class SearchPlanRequest(BaseModel):
@@ -158,7 +137,6 @@ def _safe_metrics_increment(key: str) -> None:
         return
 
 
-
 def _safe_metrics_bucket(bucket: str, key: str) -> None:
     try:
         from app import metrics_service
@@ -167,142 +145,142 @@ def _safe_metrics_bucket(bucket: str, key: str) -> None:
         return
 
 
-
-def _normalize_whitespace(text: str) -> str:
+def _normalize(text: str) -> str:
     return re.sub(r"\s+", " ", (text or "").strip())
 
 
-
-def _strip_resource_noise(query: str) -> str:
-    cleaned = RESOURCE_NOISE_RE.sub(" ", query or "")
+def strip_resource_noise(query: str) -> str:
+    cleaned = _RESOURCE_NOISE_RE.sub(" ", query or "")
+    cleaned = re.sub(r"\b(last|past)\s+\d+\s+years?\b", " ", cleaned, flags=re.IGNORECASE)
+    cleaned = re.sub(r"\b(19\d{2}|20\d{2})\b", " ", cleaned)
     cleaned = re.sub(r"\s+(AND|OR)\s+(AND|OR)\s+", " AND ", cleaned, flags=re.IGNORECASE)
     cleaned = re.sub(r"^\s*(AND|OR)\s+", "", cleaned, flags=re.IGNORECASE)
     cleaned = re.sub(r"\s+(AND|OR)\s*$", "", cleaned, flags=re.IGNORECASE)
-    return _normalize_whitespace(cleaned)
+    return _normalize(cleaned).strip(".?,")
 
 
+def _light_correct_question(question: str) -> str:
+    q = _normalize(question)
+    q = re.sub(r"\bpeer reviewd\b", "peer reviewed", q, flags=re.IGNORECASE)
+    q = re.sub(r"\bpubmedd\b", "PubMed", q, flags=re.IGNORECASE)
+    q = q.rstrip(".?")
+    if q and not q.endswith("."):
+        q += "."
+    return q
 
-def _extract_topic(question: str) -> str:
-    q = _normalize_whitespace(question)
+
+def extract_topic_from_question(question: str) -> str:
+    q = _normalize(question)
     lower = q.lower()
-    for pat in PREFIX_PATTERNS:
-        lower_after = re.sub(pat, "", lower, count=1)
-        if lower_after != lower:
-            lower = lower_after
+    for prefix in _PREFIXES:
+        if lower.startswith(prefix):
+            q = q[len(prefix):]
             break
-    lower = re.sub(r"\b(last|past)\s+\d{1,2}\s+years?\b", " ", lower)
-    lower = re.sub(r"\bfrom\s+(19|20)\d{2}\s+(?:to|and|-)+\s+(19|20)\d{2}\b", " ", lower)
-    lower = re.sub(r"\b(19|20)\d{2}\b", " ", lower)
-    lower = _strip_resource_noise(lower)
-    return lower.strip(" .?") or _strip_resource_noise(question)
-
+    q = strip_resource_noise(q)
+    q = re.sub(r"^(on|about|for)\s+", "", q, flags=re.IGNORECASE)
+    return _normalize(q).strip(".?") or _normalize(question).strip(".?")
 
 
-def _derive_resource_type_from_text(question: str, override: Optional[str] = None) -> str:
-    if override in {"articles", "books", "both"}:
-        return override
+def derive_resource_type(question: str, explicit: Optional[str] = None) -> str:
+    if explicit in {"articles", "books", "both"}:
+        return explicit
     q = (question or "").lower()
-    if any(x in q for x in ["books", "book", "ebook", "ebooks"]):
+    if any(t in q for t in ["book", "books", "ebook", "ebooks"]):
         return "books"
-    if any(x in q for x in ["articles", "article", "papers", "paper", "journals", "journal", "studies", "study"]):
+    if any(t in q for t in ["article", "articles", "paper", "papers", "journal", "journals", "study", "studies"]):
         return "articles"
-    return "both"
+    return "articles"
 
 
-
-def _is_medical_query(question: str) -> bool:
-    return bool(MEDICAL_HINT_RE.search(question or ""))
-
+def is_medical_query(question: str, topic: str = "") -> bool:
+    return bool(_MEDICAL_HINT_RE.search(f"{question} {topic}"))
 
 
 def _quote_term(term: str) -> str:
-    term = _normalize_whitespace(term)
+    term = _normalize(term)
     if not term:
         return ""
-    if "*" in term:
+    if re.fullmatch(r"[A-Z]{2,6}", term):
         return term
-    if " " in term or "-" in term:
+    if re.fullmatch(r"[A-Za-z0-9_-]+", term):
         return f'"{term}"'
-    return term
-
-
+    return f'"{term}"'
 
-def _longest_phrase_match(tokens: List[str], start: int) -> Optional[str]:
-    max_len = min(3, len(tokens) - start)
-    for length in range(max_len, 0, -1):
-        phrase = " ".join(tokens[start:start + length]).lower()
-        if phrase in PHRASE_SYNONYMS:
-            return phrase
-    return None
 
+def _dedupe_keep_order(items: List[str]) -> List[str]:
+    seen = set()
+    out = []
+    for item in items:
+        norm = item.lower().strip()
+        if not norm or norm in seen:
+            continue
+        seen.add(norm)
+        out.append(item)
+    return out
 
 
-def _concept_groups(topic: str) -> List[List[str]]:
-    topic = _normalize_whitespace(topic).lower()
-    raw_tokens = [t for t in re.findall(r"[a-z0-9]+", topic) if t not in STOP_WORDS and len(t) > 2]
+def _build_concept_groups(topic: str) -> List[List[str]]:
+    work = f" {_normalize(topic).lower()} "
     groups: List[List[str]] = []
-    i = 0
-    while i < len(raw_tokens):
-        phrase = _longest_phrase_match(raw_tokens, i)
-        if phrase:
-            synonyms = PHRASE_SYNONYMS.get(phrase, [])
-            group = [phrase] + [s for s in synonyms if s.lower() != phrase]
-            groups.append(group)
-            i += len(phrase.split())
-            continue
-        token = raw_tokens[i]
-        group = [token]
-        group.extend([s for s in TOKEN_SYNONYMS.get(token, []) if s.lower() != token])
-        groups.append(group)
-        i += 1
-
-    if not groups and topic:
-        return [[topic]]
-
-    # collapse duplicate/single-token noise but preserve order
-    cleaned_groups: List[List[str]] = []
-    seen_primary = set()
-    for group in groups:
-        primary = group[0].lower()
-        if primary in seen_primary:
+    phrase_keys = sorted(PHRASE_SYNONYMS, key=lambda x: len(x[0]), reverse=True)
+    for phrase, syns in phrase_keys:
+        needle = f" {phrase} "
+        if needle in work:
+            groups.append(_dedupe_keep_order([phrase] + syns))
+            work = work.replace(needle, " ")
+
+    leftovers = [w for w in re.findall(r"[a-z0-9]+", work) if len(w) > 2 and w not in {
+        "and", "or", "for", "with", "from", "into", "onto", "about", "using", "based", "among",
+        "between", "effects", "effect", "impact", "role", "use", "uses", "application", "applications",
+    }]
+    for token in leftovers:
+        groups.append(_dedupe_keep_order([token] + TOKEN_SYNONYMS.get(token, [])))
+
+    if not groups:
+        cleaned = strip_resource_noise(topic)
+        if cleaned:
+            groups = [[cleaned]]
+    return groups
+
+
+def build_boolean_query(topic: str) -> str:
+    groups = _build_concept_groups(topic)
+    parts = []
+    for group in groups[:4]:
+        tokens = [_quote_term(term) for term in group if term]
+        tokens = [t for t in tokens if t]
+        if not tokens:
             continue
-        seen_primary.add(primary)
-        unique_terms = []
-        seen_terms = set()
-        for term in group:
-            norm = term.lower()
-            if norm in seen_terms:
-                continue
-            seen_terms.add(norm)
-            unique_terms.append(term)
-        cleaned_groups.append(unique_terms)
-    return cleaned_groups[:4]
-
-
-
-def build_primo_boolean_query(topic: str) -> str:
-    clean_topic = _strip_resource_noise(topic)
-    groups = _concept_groups(clean_topic)
-    clauses: List[str] = []
-    for group in groups:
-        if not group:
-            continue
-        if len(group) == 1:
-            clauses.append(_quote_term(group[0]))
+        if len(tokens) == 1:
+            parts.append(f"({tokens[0]})")
         else:
-            clauses.append("(" + " OR ".join(_quote_term(term) for term in group) + ")")
-    if not clauses:
-        return _quote_term(clean_topic or topic)
-    return " AND ".join(clauses)
+            parts.append("(" + " OR ".join(tokens) + ")")
+    return " AND ".join(parts) if parts else f'({_quote_term(topic)})'
+
 
+def build_pubmed_url(query: str, year_from: Optional[str] = None, year_to: Optional[str] = None) -> str:
+    url = f"https://pubmed.ncbi.nlm.nih.gov/?term={quote(strip_resource_noise(query) or query)}"
+    if year_from or year_to:
+        yf = year_from or "1900"
+        yt = year_to or "3000"
+        url += f"&filter=datesearch.y_custom&dates.from={yf}&dates.to={yt}"
+    return url
 
 
-def _primo_facets(resource_type: str = "both", peer_reviewed: bool = False, open_access: bool = False, year_from: Optional[str] = None, year_to: Optional[str] = None) -> List[str]:
-    facets: List[str] = []
+def build_primo_discovery_url(boolean_query: str, resource_type: str = "both", peer_reviewed: bool = False,
+                              open_access: bool = False, year_from: Optional[str] = None, year_to: Optional[str] = None) -> str:
+    facets = []
     if resource_type == "articles":
         facets.append("rtype,include,articles")
+        tab = "CentralIndex"
+        scope = "CentralIndex"
     elif resource_type == "books":
         facets.append("rtype,include,books")
+        tab = "Everything"
+        scope = "MyInst_and_CI"
+    else:
+        tab = "Everything"
+        scope = "MyInst_and_CI"
     if peer_reviewed:
         facets.append("tlevel,include,peer_reviewed")
     if open_access:
@@ -311,76 +289,49 @@ def _primo_facets(resource_type: str = "both", peer_reviewed: bool = False, open
         yf = year_from or "0001"
         yt = year_to or "9999"
         facets.append(f"searchcreationdate,include,{yf}|,|{yt}")
-    return facets
-
-
-
-def build_primo_discovery_url(boolean_query: str, resource_type: str = "both", peer_reviewed: bool = False, open_access: bool = False, year_from: Optional[str] = None, year_to: Optional[str] = None, tab: str = "Everything", scope: str = "MyInst_and_CI") -> str:
-    url = (
-        f"{PRIMO_BASE}&query=any,contains,{quote(boolean_query)}"
-        f"&tab={tab}&search_scope={scope}&lang=en&mode=advanced&offset=0"
-    )
-    for facet in _primo_facets(resource_type, peer_reviewed, open_access, year_from, year_to):
+    url = f"{PRIMO_BASE_URL}&query=any,contains,{quote(boolean_query)}&lang=en&mode=advanced&offset=0&tab={tab}&search_scope={scope}"
+    for facet in facets:
         url += f"&facet={quote(facet)}"
     return url
 
 
-
-def build_pubmed_url(query: str, year_from: Optional[str] = None, year_to: Optional[str] = None, peer_reviewed: bool = False) -> str:
-    clean_query = _strip_resource_noise(query) or query
-    term = clean_query
-    if peer_reviewed:
-        term = f"({term}) AND Journal Article[pt]"
-    url = f"https://pubmed.ncbi.nlm.nih.gov/?term={quote(term)}"
-    if year_from or year_to:
-        yf = year_from or "1900"
-        yt = year_to or str(CURRENT_YEAR)
-        url += f"&filter=datesearch.y_custom&dates.from={yf}&dates.to={yt}"
-    return url
-
-
-async def _grammar_refine_query(text: str) -> str:
-    settings = get_settings()
-    if not settings.openai_api_key:
-        return _normalize_whitespace(text)
-    try:
-        from langchain_openai import ChatOpenAI
-        llm = ChatOpenAI(model="gpt-4o-mini", temperature=0, max_tokens=60, openai_api_key=settings.openai_api_key)
-        response = await llm.ainvoke([
-            {"role": "system", "content": "Rewrite the user's search query in clear grammatical English. Keep meaning exactly the same. Return one sentence only."},
-            {"role": "user", "content": text},
-        ])
-        return _normalize_whitespace(response.content) or _normalize_whitespace(text)
-    except Exception:
-        return _normalize_whitespace(text)
+def build_search_plan(question: str, peer_reviewed: bool = False, open_access: bool = False,
+                      year_from: Optional[str] = None, year_to: Optional[str] = None,
+                      resource_type: Optional[str] = None) -> dict:
+    corrected_question = _light_correct_question(question)
+    topic = extract_topic_from_question(corrected_question)
+    resource = derive_resource_type(corrected_question, resource_type)
+    medical = is_medical_query(corrected_question, topic)
+    bool_query = build_boolean_query(topic)
+    all_url = build_primo_discovery_url(bool_query, "both", peer_reviewed, open_access, year_from, year_to)
+    art_url = build_primo_discovery_url(bool_query, "articles", peer_reviewed, open_access, year_from, year_to)
+    book_url = build_primo_discovery_url(bool_query, "books", peer_reviewed, open_access, year_from, year_to)
+    return {
+        "question": corrected_question,
+        "topic": topic,
+        "display_topic": topic,
+        "resource_type": resource,
+        "is_medical": medical,
+        "ai_tool_query": corrected_question,
+        "primo_boolean_query": bool_query,
+        "primo_all_url": all_url,
+        "primo_articles_url": art_url,
+        "primo_books_url": book_url,
+        "primo_ai_url": f"{PRIMO_AI_URL}{quote(corrected_question)}",
+        "pubmed_url": build_pubmed_url(topic, year_from, year_to) if medical else "",
+    }
 
 
 @router.post("/plan")
 async def search_plan_endpoint(req: SearchPlanRequest):
-    _safe_metrics_increment("search_plans")
-    topic = _extract_topic(req.question)
-    resource_type = _derive_resource_type_from_text(req.question, req.resource_type)
-    boolean_query = build_primo_boolean_query(topic)
-    ai_tool_query = await _grammar_refine_query(req.question)
-    is_medical = _is_medical_query(req.question) or _is_medical_query(topic)
-
-    return {
-        "topic": topic,
-        "display_topic": topic.title(),
-        "resource_type": resource_type,
-        "is_medical": is_medical,
-        "ai_tool_query": ai_tool_query,
-        "primo_boolean_query": boolean_query,
-        "primo_all_url": build_primo_discovery_url(boolean_query, "both", req.peer_reviewed, req.open_access, req.year_from, req.year_to, "Everything", "MyInst_and_CI"),
-        "primo_articles_url": build_primo_discovery_url(boolean_query, "articles", req.peer_reviewed, req.open_access, req.year_from, req.year_to, "CentralIndex", "CentralIndex"),
-        "primo_books_url": build_primo_discovery_url(boolean_query, "books", req.peer_reviewed, req.open_access, req.year_from, req.year_to, "Everything", "MyInst_and_CI"),
-        "primo_ai_url": f"{PRIMO_AI_BASE}{quote(ai_tool_query)}",
-        "pubmed_url": build_pubmed_url(topic, req.year_from, req.year_to, req.peer_reviewed) if is_medical else None,
-        "ebsco_ai_url": f"{EBSCO_AI_BASE}{quote(ai_tool_query)}",
-        "scopus_ai_url": f"{SCOPUS_AI_BASE}{quote(ai_tool_query)}",
-        "leapspace_url": f"{LEAPSPACE_BASE}{quote(ai_tool_query)}",
-        "consensus_url": f"{CONSENSUS_BASE}{quote(ai_tool_query)}",
-    }
+    return build_search_plan(
+        req.question,
+        peer_reviewed=req.peer_reviewed,
+        open_access=req.open_access,
+        year_from=req.year_from,
+        year_to=req.year_to,
+        resource_type=req.resource_type,
+    )
 
 
 @router.post("")
@@ -401,55 +352,59 @@ async def search_primo(req: SearchRequest, api_key: str):
         _safe_metrics_bucket("errors", "primo_missing_api_key")
         return {"error": "PRIMO_API_KEY not configured", "results": [], "source": "PRIMO"}
 
-    clean_query = _strip_resource_noise(req.query)
-    if not clean_query:
-        clean_query = req.query
-
-    boolean_query = req.boolean_query or build_primo_boolean_query(clean_query)
-    query_for_api = boolean_query
+    clean_query = strip_resource_noise(req.query) or req.query
+    use_boolean = bool(req.boolean_query and req.boolean_query.strip())
+    actual_query = req.boolean_query.strip() if use_boolean else clean_query
 
-    def _build_api_url(query_text: str) -> str:
+    def make_url(q: str) -> str:
+        query_encoded = quote(q)
         url = (
             f"https://api-eu.hosted.exlibrisgroup.com/primo/v1/search"
             f"?vid=971KUOSTAR_INST:KU&tab=Everything&scope=MyInst_and_CI"
-            f"&q=any,contains,{quote(query_text)}&lang=en&sort=rank&limit={req.limit}"
+            f"&q=any,contains,{query_encoded}&lang=en&sort=rank&limit={req.limit}"
             f"&offset=0&mode=advanced&apikey={api_key}"
         )
-        api_facets = []
+        facets = []
         if req.resource_type == "articles":
-            api_facets.append("facet_rtype,include,articles")
+            facets.append("facet_rtype,include,articles")
         elif req.resource_type == "books":
-            api_facets.append("facet_rtype,include,books")
+            facets.append("facet_rtype,include,books")
         if req.peer_reviewed:
-            api_facets.append("facet_tlevel,include,peer_reviewed")
+            facets.append("facet_tlevel,include,peer_reviewed")
         if req.open_access:
-            api_facets.append("facet_tlevel,include,online_resources")
+            facets.append("facet_tlevel,include,online_resources")
         if req.year_from or req.year_to:
             yf = req.year_from or "0001"
             yt = req.year_to or "9999"
-            api_facets.append(f"facet_searchcreationdate,include,{yf}|,|{yt}")
-        for facet in api_facets:
+            facets.append(f"facet_searchcreationdate,include,{yf}|,|{yt}")
+        for facet in facets:
             url += f"&multiFacets={quote(facet)}"
         return url
 
-    logger.info("PRIMO boolean=%r clean_query=%r resource_type=%s", boolean_query, clean_query, req.resource_type)
+    logger.info("PRIMO actual_query=%r clean_query=%r boolean=%s", actual_query, clean_query, use_boolean)
 
     try:
         async with httpx.AsyncClient(timeout=20) as client:
-            url = _build_api_url(query_for_api)
-            r = await client.get(url, headers={"Accept": "application/json"})
-            if r.status_code == 400 and boolean_query != clean_query:
-                logger.warning("PRIMO 400 on boolean query; falling back to clean keywords")
-                url = _build_api_url(clean_query)
-                r = await client.get(url, headers={"Accept": "application/json"})
+            r = await client.get(make_url(actual_query), headers={"Accept": "application/json"})
+            if r.status_code == 400 and use_boolean:
+                logger.warning("PRIMO rejected boolean query; falling back to clean keywords")
+                r = await client.get(make_url(clean_query), headers={"Accept": "application/json"})
+                actual_query = clean_query
             logger.info("PRIMO status=%s", r.status_code)
             if r.status_code != 200:
                 _safe_metrics_bucket("errors", f"primo_{r.status_code}")
                 return {"error": f"PRIMO API error: {r.status_code}", "results": [], "source": "PRIMO"}
-
             data = r.json()
             docs = data.get("docs", [])
-            discovery_url = build_primo_discovery_url(boolean_query, req.resource_type, req.peer_reviewed, req.open_access, req.year_from, req.year_to)
+            display_query = req.boolean_query.strip() if req.boolean_query else clean_query
+            discovery_url = build_primo_discovery_url(
+                display_query,
+                req.resource_type,
+                req.peer_reviewed,
+                req.open_access,
+                req.year_from,
+                req.year_to,
+            )
             results = []
             for doc in docs[: req.limit]:
                 pnx = doc.get("pnx", {})
@@ -464,7 +419,6 @@ async def search_primo(req: SearchRequest, api_key: str):
                     "_source": "PRIMO",
                 })
             return {"total": data.get("info", {}).get("total", 0), "results": results, "source": "PRIMO"}
-
     except httpx.TimeoutException:
         _safe_metrics_bucket("errors", "primo_timeout")
         return {"error": "PRIMO API timed out — please try again", "results": [], "source": "PRIMO"}
@@ -475,9 +429,7 @@ async def search_primo(req: SearchRequest, api_key: str):
 
 
 async def search_pubmed(req: SearchRequest):
-    clean_query = _strip_resource_noise(req.query)
-    if not clean_query:
-        clean_query = req.query
+    clean_query = strip_resource_noise(req.query) or req.query
     term = clean_query
     if req.peer_reviewed:
         term = f"({term}) AND Journal Article[pt]"
@@ -538,7 +490,11 @@ async def search_pubmed(req: SearchRequest):
 
 async def search_scholar(req: SearchRequest):
     try:
-        params = {"query": req.query, "limit": req.limit, "fields": "title,authors,year,venue,externalIds,citationCount"}
+        params = {
+            "query": req.query,
+            "limit": req.limit,
+            "fields": "title,authors,year,venue,externalIds,citationCount",
+        }
         async with httpx.AsyncClient(timeout=15) as client:
             r = await client.get("https://api.semanticscholar.org/graph/v1/paper/search", params=params)
             if r.status_code != 200: