feat: add LLM-based query rewriting

app/engine/query_transform.py

@@ -1,5 +1,12 @@
+import json
 import re
 
+from langchain_core.prompts import PromptTemplate
+from langchain_ollama import ChatOllama
+
+from app.core.config import settings
+from app.core.logging import logger
+
 
 def normalize_query(query: str) -> str:
     return re.sub(r"\s+", " ", query).strip()
@@ -8,8 +15,34 @@ def normalize_query(query: str) -> str:
 def query_variants(query: str) -> list[str]:
     normalized = normalize_query(query)
     variants = [normalized]
-    if "error" in normalized.lower() and "troubleshoot" not in normalized.lower():
-        variants.append(f"troubleshoot {normalized}")
-    if "how" in normalized.lower() and "steps" not in normalized.lower():
-        variants.append(f"{normalized} steps")
+    
+    try:
+        llm = ChatOllama(
+            model=settings.OLLAMA_MODEL, 
+            temperature=0, 
+            format="json", 
+            base_url=settings.OLLAMA_BASE_URL
+        )
+        prompt = PromptTemplate(
+            template="""You are an expert technical support assistant. 
+Your goal is to generate 2 alternative phrasing variants for the user's question to improve retrieval accuracy.
+Return ONLY a JSON object with a single key 'variants' containing a list of strings.
+
+User Question: {question}""",
+            input_variables=["question"],
+        )
+        chain = prompt | llm
+        result = chain.invoke({"question": normalized})
+        
+        parsed = json.loads(result.content)
+        new_variants = parsed.get("variants", [])
+        
+        if isinstance(new_variants, list):
+            for variant in new_variants:
+                if isinstance(variant, str) and variant.strip():
+                    variants.append(variant.strip())
+                    
+    except Exception as e:
+        logger.warning(f"Failed to generate query variants with LLM: {e}")
+        
     return list(dict.fromkeys(variants))

tests/test_retriever.py

@@ -0,0 +1,29 @@
+from unittest.mock import patch
+
+from app.engine.query_transform import normalize_query, query_variants
+
+
+def test_query_normalization_collapses_whitespace():
+    assert normalize_query("  reset   password \n now ") == "reset password now"
+
+
+@patch("app.engine.query_transform.ChatOllama")
+def test_query_variants_add_helpful_expansions(mock_chat):
+    mock_instance = mock_chat.return_value
+    class MockResult:
+        content = '{"variants": ["troubleshoot error 404 steps"]}'
+    
+    mock_chain_invoke = mock_instance.invoke
+    mock_chain_invoke.return_value = MockResult()
+    
+    # We also have to mock the prompt | llm chain, which returns a RunnableSequence
+    # A simpler way is to mock the chain.invoke, but it's built inline. 
+    # Let's mock ChatOllama.invoke to return the expected json if it's called directly by prompt | llm? No, ChatOllama gets passed prompt string.
+    # We can patch ChatOllama.invoke
+    mock_instance.invoke.return_value = MockResult()
+
+    variants = query_variants("How to fix error 404?")
+
+    assert "How to fix error 404?" in variants
+    # The LLM mock adds "troubleshoot error 404 steps"
+    assert "troubleshoot error 404 steps" in variants