Update src/api/agent.py

src/api/agent.py

@@ -705,16 +705,117 @@ async def _extract_topic(question: str, model: str) -> str:
 # They are now self-contained here.
 
 def _shared_build_primo_boolean_query(topic: str) -> str:
-    """Build a clean boolean query from topic keywords — no resource-type words."""
+    """
+    Regex fallback for boolean query construction — used only when LLM is unavailable.
+    Keeps multi-word phrases quoted, strips stop words, ANDs remaining concepts.
+    Does NOT split known compound terms.
+    """
     clean = _strip_resource_noise(topic)
     if not clean:
         clean = topic
-    keywords = [w for w in clean.split() if len(w) > 1]
-    if not keywords:
-        return clean
-    if len(keywords) == 1:
-        return keywords[0]
-    return " AND ".join(keywords[:5])
+    clean = _normalize_whitespace(clean)
+
+    # Treat the whole cleaned topic as a single phrase if ≤ 4 words
+    words = clean.split()
+    if len(words) <= 4:
+        return f'"{clean}"'
+
+    # For longer topics: split on stop words, quote resulting multi-word chunks
+    _BOOL_STOP = re.compile(
+        r"\b(of|on|in|the|a|an|and|or|for|to|with|by|from|at|is|are|was|were|"
+        r"be|been|have|has|had|do|does|did|will|would|could|should|may|its|"
+        r"this|that|these|those|about|impact|role|effect|use|analysis|review|"
+        r"what|how|why|when|where|which|between|within|across|among|using|"
+        r"based|related|towards|toward|during|after|before|over|under)\b",
+        re.IGNORECASE,
+    )
+    # Split on stop words, keep non-stop chunks
+    parts = _BOOL_STOP.split(clean)
+    concepts = [_normalize_whitespace(p) for p in parts if _normalize_whitespace(p) and len(_normalize_whitespace(p)) > 2]
+    if not concepts:
+        return f'"{clean}"'
+    if len(concepts) == 1:
+        return f'"{concepts[0]}"'
+    # Quote multi-word concepts, leave single words bare
+    quoted = [f'"{c}"' if ' ' in c else c for c in concepts[:4]]
+    return " AND ".join(quoted)
+
+
+_BOOLEAN_SYSTEM = """You are an expert academic database search specialist building PRIMO/ExLibris boolean queries.
+
+Given a research topic or question, output ONLY a valid boolean search string.
+
+RULES:
+1. Identify 2-4 key CONCEPTS in the query.
+2. Multi-word concepts MUST be quoted: "machine learning" not machine AND learning.
+3. Use OR between synonyms of the same concept: ("machine learning" OR "deep learning" OR "neural networks")
+4. Use AND to connect different concepts: ("climate change" OR "global warming") AND ("renewable energy" OR "clean energy")
+5. NEVER split a natural phrase with AND: "global warming" stays "global warming", NOT global AND warming.
+6. NEVER include stop words (of, the, a, in, on, for, to, with, by, impact, role, effect, use, study, analysis, review) as standalone terms.
+7. For medical/clinical topics, include MeSH-style synonyms.
+8. Keep to a maximum of 3 concept groups joined by AND.
+9. Return ONLY the boolean string. No explanation, no preamble, no markdown.
+
+EXAMPLES:
+Input: global warming
+Output: ("global warming" OR "climate change" OR "greenhouse effect")
+
+Input: machine learning in healthcare
+Output: ("machine learning" OR "deep learning" OR "artificial intelligence") AND ("healthcare" OR "medicine" OR "clinical")
+
+Input: impact of social media on mental health
+Output: ("social media" OR "social networks") AND ("mental health" OR "psychological wellbeing" OR "depression")
+
+Input: structural engineering UAE
+Output: ("structural engineering" OR "structural analysis") AND ("UAE" OR "United Arab Emirates" OR "Gulf")
+
+Input: CRISPR gene editing applications
+Output: ("CRISPR" OR "CRISPR-Cas9" OR "gene editing") AND ("applications" OR "therapeutic" OR "treatment")
+
+Input: renewable energy policy
+Output: ("renewable energy" OR "clean energy" OR "sustainable energy") AND ("policy" OR "regulation" OR "governance")
+"""
+
+
+async def _llm_build_boolean_query(topic: str, model: str) -> str:
+    """
+    Use LLM to generate a high-quality PRIMO boolean query with:
+    - Quoted multi-word phrases
+    - OR synonyms within concept groups
+    - AND between distinct concepts
+    Falls back to regex version if LLM fails.
+    """
+    settings = get_settings()
+    if not settings.openai_api_key and not settings.anthropic_api_key:
+        return _shared_build_primo_boolean_query(topic)
+    try:
+        llm = _get_llm(model, temperature=0, max_tokens=120)
+        response = await llm.ainvoke([
+            {"role": "system", "content": _BOOLEAN_SYSTEM},
+            {"role": "user", "content": f"Input: {topic.strip()}"},
+        ])
+        result = response.content.strip()
+        # Sanity checks — must contain quotes and AND/OR or be a short phrase
+        if not result or len(result) > 500:
+            raise ValueError("Bad LLM boolean output")
+        # Strip any markdown the LLM snuck in
+        result = re.sub(r"^```[a-z]*\n?", "", result).rstrip("`").strip()
+        # Must have at least one quote or look like a valid query
+        if '"' not in result and ' AND ' not in result and ' OR ' not in result:
+            # Wrap bare output as a phrase
+            result = f'"{result}"'
+        logger.info(f"LLM boolean: {result!r} ← topic: {topic!r}")
+        return result
+    except Exception as e:
+        logger.warning(f"LLM boolean query failed: {e} — using regex fallback")
+        return _shared_build_primo_boolean_query(topic)
+
+
+def _make_primo_boolean_query(context: SearchContextPayload) -> str:
+    """Sync wrapper — returns regex boolean. Async LLM version called from _prepare_queries."""
+    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)
 
 
 def _shared_build_primo_discovery_url(
@@ -870,7 +971,9 @@ async def _prepare_queries(question: str, context: SearchContextPayload, model:
     natural = _compose_ai_tool_query(question, context, is_follow_up)
     natural = await _grammar_refine_query(natural, model)
     context.ai_tool_query = natural
-    context.primo_boolean_query = _make_primo_boolean_query(context)
+    # Use LLM to build a high-quality boolean query with quoted phrases and OR synonyms
+    topic = _strip_resource_noise(context.display_topic or context.topic) or context.topic
+    context.primo_boolean_query = await _llm_build_boolean_query(topic, model)
     return context