+ {{ results_reranked.reranker_skip_reason }}
+
+ {% endif %}
diff --git a/mnemosyne/library/templates/library/search.html b/mnemosyne/library/templates/library/search.html
index 1a7f47c..b7e6b62 100644
--- a/mnemosyne/library/templates/library/search.html
+++ b/mnemosyne/library/templates/library/search.html
@@ -81,12 +81,30 @@
Search Types
diff --git a/mnemosyne/library/tests/test_reranker.py b/mnemosyne/library/tests/test_reranker.py
index 813699f..7d0f5d8 100644
--- a/mnemosyne/library/tests/test_reranker.py
+++ b/mnemosyne/library/tests/test_reranker.py
@@ -29,10 +29,15 @@ def _make_candidate(chunk_uid: str, text_preview: str = "Some text", **kwargs):
def _mock_reranker_model():
- """Create a mock LLMModel for reranking."""
+ """Create a mock LLMModel for reranking.
+
+ ``base_url`` follows the project-wide convention: it is the
+ OpenAI-style ``/v1`` root. Every service client (embedding, vision,
+ concepts, reranker) appends a path-only segment to it.
+ """
model = MagicMock()
model.name = "qwen3-vl-reranker-2b"
- model.api.base_url = "http://pan.helu.ca:8400"
+ model.api.base_url = "http://pan.helu.ca:8400/v1"
model.api.api_key = ""
model.api.timeout_seconds = 30
model.input_cost_per_1k = Decimal("0")
@@ -49,7 +54,7 @@ class RerankerClientInitTest(TestCase):
client = RerankerClient(model)
self.assertEqual(client.model_name, "qwen3-vl-reranker-2b")
- self.assertEqual(client.base_url, "http://pan.helu.ca:8400")
+ self.assertEqual(client.base_url, "http://pan.helu.ca:8400/v1")
class RerankerClientRerankTest(TestCase):
@@ -198,6 +203,33 @@ class RerankerClientRerankTest(TestCase):
with self.assertRaises(Exception):
client.rerank(query="test", candidates=candidates)
+ @patch("library.services.reranker.requests.post")
+ def test_request_url_is_base_plus_rerank(self, mock_post):
+ """URL is ``{base_url}/rerank`` — base_url already contains ``/v1``.
+
+ Regression guard: earlier versions prepended ``/v1/`` inside the
+ client, which produced ``…/v1/v1/rerank`` and 404 against Synesis
+ when the ``LLMApi.base_url`` followed the same convention as the
+ embedding / chat / vision clients.
+ """
+ mock_response = MagicMock()
+ mock_response.status_code = 200
+ mock_response.json.return_value = {
+ "results": [{"index": 0, "score": 0.5}],
+ }
+ mock_post.return_value = mock_response
+
+ model = _mock_reranker_model()
+ client = RerankerClient(model)
+ candidates = [_make_candidate("a")]
+
+ client.rerank(query="test", candidates=candidates)
+
+ # First positional arg to requests.post is the URL.
+ called_url = mock_post.call_args.args[0] if mock_post.call_args.args \
+ else mock_post.call_args.kwargs.get("url")
+ self.assertEqual(called_url, "http://pan.helu.ca:8400/v1/rerank")
+
@patch("library.services.reranker.requests.post")
def test_no_instruction_omits_field(self, mock_post):
"""Empty instruction is not sent in payload."""
diff --git a/mnemosyne/library/tests/test_search.py b/mnemosyne/library/tests/test_search.py
index 5b34ad4..8189563 100644
--- a/mnemosyne/library/tests/test_search.py
+++ b/mnemosyne/library/tests/test_search.py
@@ -52,7 +52,7 @@ class SearchServiceSearchTest(TestCase):
]
mock_fulltext.return_value = []
mock_graph.return_value = []
- mock_rerank.return_value = (None, None)
+ mock_rerank.return_value = (None, None, "no_system_model")
mock_image.return_value = []
request = SearchRequest(
@@ -110,7 +110,9 @@ class SearchServiceSearchTest(TestCase):
chunk_s3_key="s3/key", chunk_index=0, score=0.95,
source="fulltext",
)
- mock_rerank.return_value = ([reranked_candidate], "qwen3-vl-reranker-2b")
+ mock_rerank.return_value = (
+ [reranked_candidate], "qwen3-vl-reranker-2b", None,
+ )
request = SearchRequest(
query="test",
@@ -125,6 +127,8 @@ class SearchServiceSearchTest(TestCase):
self.assertTrue(response.reranker_used)
self.assertEqual(response.reranker_model, "qwen3-vl-reranker-2b")
self.assertAlmostEqual(response.candidates[0].score, 0.95)
+ # Successful rerank → no skip reason surfaced to UI / API.
+ self.assertIsNone(response.reranker_skip_reason)
@patch("library.services.search.SearchService._fulltext_search")
@patch("library.services.search.SearchService._embed_query")
@@ -152,6 +156,103 @@ class SearchServiceSearchTest(TestCase):
self.assertFalse(response.reranker_used)
self.assertIsNone(response.reranker_model)
+ # ``rerank=False`` means "not requested", not "skipped" — so no
+ # reason is reported. Template distinguishes this from the
+ # skip case by looking at the original request's rerank flag.
+ self.assertIsNone(response.reranker_skip_reason)
+
+ @patch("library.services.search.SearchService._rerank")
+ @patch("library.services.search.SearchService._fulltext_search")
+ @patch("library.services.search.SearchService._embed_query")
+ def test_search_reports_skip_reason_no_system_model(
+ self, mock_embed, mock_fulltext, mock_rerank
+ ):
+ """Rerank requested but no system model → ``no_system_model`` surfaced."""
+ mock_embed.return_value = None
+ mock_fulltext.return_value = [
+ SearchCandidate(
+ chunk_uid="c1", item_uid="i1", item_title="Test",
+ library_type="technical", text_preview="preview",
+ chunk_s3_key="s3/key", chunk_index=0, score=0.5,
+ source="fulltext",
+ )
+ ]
+ mock_rerank.return_value = (None, None, "no_system_model")
+
+ request = SearchRequest(
+ query="test",
+ search_types=["fulltext"],
+ rerank=True,
+ include_images=False,
+ )
+
+ service = SearchService()
+ response = service.search(request)
+
+ self.assertFalse(response.reranker_used)
+ self.assertIsNone(response.reranker_model)
+ self.assertEqual(response.reranker_skip_reason, "no_system_model")
+
+ @patch("library.services.search.SearchService._rerank")
+ @patch("library.services.search.SearchService._fulltext_search")
+ @patch("library.services.search.SearchService._embed_query")
+ def test_search_reports_skip_reason_api_error(
+ self, mock_embed, mock_fulltext, mock_rerank
+ ):
+ """Rerank API raising → ``api_error: ...`` surfaced in response."""
+ mock_embed.return_value = None
+ mock_fulltext.return_value = [
+ SearchCandidate(
+ chunk_uid="c1", item_uid="i1", item_title="Test",
+ library_type="technical", text_preview="preview",
+ chunk_s3_key="s3/key", chunk_index=0, score=0.5,
+ source="fulltext",
+ )
+ ]
+ mock_rerank.return_value = (
+ None, None,
+ "api_error: 404 Client Error: Not Found for url: "
+ "http://pan.helu.ca:8400/v1/v1/rerank",
+ )
+
+ request = SearchRequest(
+ query="test",
+ search_types=["fulltext"],
+ rerank=True,
+ include_images=False,
+ )
+
+ service = SearchService()
+ response = service.search(request)
+
+ self.assertFalse(response.reranker_used)
+ self.assertIsNotNone(response.reranker_skip_reason)
+ self.assertTrue(
+ response.reranker_skip_reason.startswith("api_error:"),
+ f"expected api_error: prefix, got {response.reranker_skip_reason!r}",
+ )
+
+ @patch("library.services.search.SearchService._fulltext_search")
+ @patch("library.services.search.SearchService._embed_query")
+ def test_search_reports_skip_reason_no_candidates(
+ self, mock_embed, mock_fulltext
+ ):
+ """Rerank requested but fusion produced nothing → ``no_candidates``."""
+ mock_embed.return_value = None
+ mock_fulltext.return_value = []
+
+ request = SearchRequest(
+ query="test",
+ search_types=["fulltext"],
+ rerank=True,
+ include_images=False,
+ )
+
+ service = SearchService()
+ response = service.search(request)
+
+ self.assertFalse(response.reranker_used)
+ self.assertEqual(response.reranker_skip_reason, "no_candidates")
@patch("library.services.search.SearchService._fulltext_search")
@patch("library.services.search.SearchService._embed_query")
diff --git a/mnemosyne/library/tests/test_search_api.py b/mnemosyne/library/tests/test_search_api.py
index bbf3d2e..23e1ab6 100644
--- a/mnemosyne/library/tests/test_search_api.py
+++ b/mnemosyne/library/tests/test_search_api.py
@@ -208,6 +208,41 @@ class SearchAPIResponseTest(TestCase):
self.assertEqual(call_args.search_types, ["fulltext"])
self.assertFalse(call_args.rerank)
+ @patch("library.api.views.SearchService")
+ def test_reranker_skip_reason_surfaced_in_json(self, MockService):
+ """``reranker_skip_reason`` propagates through the JSON API."""
+ mock_response = SearchResponse(
+ query="neural networks",
+ candidates=[],
+ images=[],
+ total_candidates=0,
+ search_time_ms=10.0,
+ reranker_used=False,
+ reranker_model=None,
+ search_types_used=[],
+ reranker_skip_reason=(
+ "api_error: 404 Client Error: Not Found for url: "
+ "http://pan.helu.ca:8400/v1/v1/rerank"
+ ),
+ )
+ mock_instance = MockService.return_value
+ mock_instance.search.return_value = mock_response
+
+ response = self.client.post(
+ "/library/api/search/",
+ {"query": "neural networks"},
+ format="json",
+ )
+
+ self.assertEqual(response.status_code, 200)
+ data = response.json()
+ self.assertFalse(data["reranker_used"])
+ self.assertIn("reranker_skip_reason", data)
+ self.assertTrue(
+ data["reranker_skip_reason"].startswith("api_error:"),
+ f"got {data['reranker_skip_reason']!r}",
+ )
+
class ConceptAPITest(TestCase):
"""Tests for concept API endpoints."""
diff --git a/mnemosyne/library/tests/test_search_views_admin_scope.py b/mnemosyne/library/tests/test_search_views_admin_scope.py
index e70903e..76914eb 100644
--- a/mnemosyne/library/tests/test_search_views_admin_scope.py
+++ b/mnemosyne/library/tests/test_search_views_admin_scope.py
@@ -117,11 +117,15 @@ class SearchPageAllowedLibrariesTests(TestCase):
)
self.client.force_login(self.user)
- def _patched_search(self):
+ def _patched_search(self, reranker_skip_reason=None):
"""Return a (request_capture, patch_context) pair.
The patch captures the ``SearchRequest`` that ``SearchService.search``
is called with so assertions can run after the view returns.
+
+ :param reranker_skip_reason: Value to set on the stub response's
+ ``reranker_skip_reason`` attribute, for tests that want to
+ exercise the "Skipped" badge rendering path.
"""
capture: dict = {}
@@ -137,6 +141,7 @@ class SearchPageAllowedLibrariesTests(TestCase):
reranker_used=False,
reranker_model=None,
search_types_used=[],
+ reranker_skip_reason=reranker_skip_reason,
)
return capture, patch(
@@ -178,3 +183,117 @@ class SearchPageAllowedLibrariesTests(TestCase):
)
self.assertIsNone(capture["request"].allowed_libraries)
+
+
+# ---------------------------------------------------------------------------
+# search_page rerank-status rendering
+# ---------------------------------------------------------------------------
+
+
+class SearchPageRerankBadgeTests(TestCase):
+ """Verify the three-state Re-ranked indicator on the search page.
+
+ The badge must distinguish:
+
+ * Success (``reranker_used=True``) — green "Yes"
+ * Skipped (``rerank=True`` requested but ``reranker_skip_reason`` set)
+ — warning "Skipped" with the reason shown
+ * Off (user unchecked the re-rank box) — ghost "Off"
+
+ This guards the regression that surfaced when Synesis returned 404
+ on a mis-constructed rerank URL: the UI said "No" and gave no hint
+ the re-ranker had actually failed.
+ """
+
+ def setUp(self):
+ self.user = User.objects.create_user(
+ username="admin", email="a@example.com", password="pw"
+ )
+ self.client.force_login(self.user)
+
+ def _run(self, rerank_value, reranker_used, reranker_skip_reason):
+ capture: dict = {}
+
+ def fake_search(self, request):
+ capture["request"] = request
+ return SimpleNamespace(
+ query=request.query,
+ candidates=[],
+ images=[],
+ total_candidates=0,
+ search_time_ms=0.0,
+ reranker_used=reranker_used,
+ reranker_model=None,
+ search_types_used=[],
+ reranker_skip_reason=reranker_skip_reason,
+ )
+
+ post_data = {"query": "postgresql"}
+ if rerank_value is not None:
+ post_data["rerank"] = rerank_value
+
+ with patch("library.views._all_library_uids", return_value=[]), \
+ patch("library.services.search.SearchService.search", fake_search):
+ response = self.client.post(reverse("library:search"), post_data)
+
+ self.assertEqual(response.status_code, 200)
+ return response, capture
+
+ def test_badge_shows_yes_when_rerank_succeeded(self):
+ response, _ = self._run(
+ rerank_value="on",
+ reranker_used=True,
+ reranker_skip_reason=None,
+ )
+ body = response.content.decode()
+ self.assertIn("badge-success", body)
+ self.assertIn(">Yes<", body)
+ self.assertNotIn(">Skipped<", body)
+ self.assertNotIn(">Off<", body)
+
+ def test_badge_shows_skipped_with_reason_on_api_error(self):
+ reason = (
+ "api_error: 404 Client Error: Not Found for url: "
+ "http://pan.helu.ca:8400/v1/v1/rerank"
+ )
+ response, capture = self._run(
+ rerank_value="on",
+ reranker_used=False,
+ reranker_skip_reason=reason,
+ )
+ # Sanity: the view actually requested re-ranking.
+ self.assertTrue(capture["request"].rerank)
+
+ body = response.content.decode()
+ self.assertIn(">Skipped", body)
+ # Reason shown in-page so the user can debug without grepping logs.
+ # Django auto-escapes the colon-space and URL, which is fine.
+ self.assertIn("api_error:", body)
+ self.assertIn("404", body)
+ # Must not claim success.
+ self.assertNotIn(">Yes<", body)
+
+ def test_badge_shows_skipped_on_no_system_model(self):
+ response, _ = self._run(
+ rerank_value="on",
+ reranker_used=False,
+ reranker_skip_reason="no_system_model",
+ )
+ body = response.content.decode()
+ self.assertIn(">Skipped", body)
+ self.assertIn("no_system_model", body)
+
+ def test_badge_shows_off_when_rerank_unchecked(self):
+ # HTML checkbox form: unchecked checkboxes are simply omitted
+ # from the POST body, so we pass rerank_value=None (not "off").
+ response, capture = self._run(
+ rerank_value=None,
+ reranker_used=False,
+ reranker_skip_reason=None,
+ )
+ self.assertFalse(capture["request"].rerank)
+
+ body = response.content.decode()
+ self.assertIn(">Off<", body)
+ self.assertNotIn(">Skipped", body)
+ self.assertNotIn(">Yes<", body)