fix(mcp): keep all-project search resilient

Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/mcp/project_context.py

@@ -428,7 +428,6 @@ def _canonical_memory_path_for_workspace(
     workspace_type: str,
     project_permalink: str,
     remainder: str,
-    include_project: bool,
 ) -> str:
     """Return the stored canonical path for a workspace-qualified memory URL."""
     normalized_remainder = remainder.strip("/")
@@ -523,7 +522,6 @@ async def resolve_workspace_qualified_memory_url(
         workspace_type=entry.workspace.workspace_type,
         project_permalink=entry.project.permalink,
         remainder=remainder,
-        include_project=ConfigManager().config.permalinks_include_project,
     )
     return WorkspaceMemoryUrlResolution(entry=entry, canonical_path=canonical_path)
 
@@ -1071,7 +1069,6 @@ async def resolve_project_and_path(
                     workspace_type=cached_workspace.workspace_type,
                     project_permalink=cached_project.permalink,
                     remainder=remainder,
-                    include_project=bool(include_project),
                 )
                 return cached_project, resolved_path, True
 
@@ -1094,7 +1091,6 @@ async def resolve_project_and_path(
                     workspace_type=workspace_context.workspace_type,
                     project_permalink=project_permalink,
                     remainder=remainder,
-                    include_project=bool(include_project),
                 )
                 return active_project, resolved_path, True
 

src/basic_memory/mcp/tools/search.py

@@ -436,6 +436,11 @@ def _result_total(results: dict[str, Any], raw_results: list[SearchResult | dict
     return len(raw_results) + (1 if results.get("has_more") is True else 0)
 
 
+def _project_ref_label(project_ref: dict[str, str | None]) -> str:
+    """Return a stable log label for a project search ref."""
+    return project_ref.get("project") or project_ref.get("project_id") or "<unknown project>"
+
+
 async def _search_all_projects(
     *,
     query: str | None,
@@ -474,27 +479,39 @@ async def _search_all_projects(
     any_project_has_more = False
 
     for project_ref in project_refs:
-        results = await search_notes(
-            query=query,
-            project=project_ref["project"],
-            project_id=project_ref["project_id"],
-            page=1,
-            page_size=per_project_page_size,
-            search_type=search_type,
-            output_format="json",
-            note_types=note_types or None,
-            entity_types=entity_types or None,
-            after_date=after_date,
-            metadata_filters=metadata_filters,
-            tags=tags,
-            status=status,
-            min_similarity=min_similarity,
-            search_all_projects=False,
-            context=context,
-        )
+        try:
+            results = await search_notes(
+                query=query,
+                project=project_ref["project"],
+                project_id=project_ref["project_id"],
+                page=1,
+                page_size=per_project_page_size,
+                search_type=search_type,
+                output_format="json",
+                note_types=note_types or None,
+                entity_types=entity_types or None,
+                after_date=after_date,
+                metadata_filters=metadata_filters,
+                tags=tags,
+                status=status,
+                min_similarity=min_similarity,
+                search_all_projects=False,
+                context=context,
+            )
+        except Exception as exc:
+            logger.warning(
+                f"Multi-project search failed for project {_project_ref_label(project_ref)}: {exc}"
+            )
+            continue
 
         if isinstance(results, str):
-            return results
+            if not results.startswith("# Search Failed"):
+                return results
+            logger.warning(
+                "Multi-project search failed for project "
+                f"{_project_ref_label(project_ref)}: {results}"
+            )
+            continue
 
         raw_results = _raw_results_from_search_payload(results)
         total += _result_total(results, raw_results)

tests/mcp/tools/test_search_notes_multi_project.py

@@ -165,3 +165,92 @@ async def fail_get_project_client(*args, **kwargs):
         "total": 0,
         "has_more": False,
     }
+
+
+@pytest.mark.asyncio
+async def test_search_notes_search_all_projects_continues_after_project_failure(
+    monkeypatch,
+):
+    """One failing project should not discard successful all-project search results."""
+    clients_mod = importlib.import_module("basic_memory.mcp.clients")
+    search_mod = importlib.import_module("basic_memory.mcp.tools.search")
+
+    project_refs = [
+        {
+            "project": "personal/main",
+            "project_id": "11111111-1111-1111-1111-111111111111",
+        },
+        {
+            "project": "team-paul/main",
+            "project_id": "22222222-2222-2222-2222-222222222222",
+        },
+    ]
+    warnings: list[str] = []
+
+    async def fake_load_search_project_refs(context=None):
+        return project_refs
+
+    class StubProject:
+        def __init__(self, name: str | None, external_id: str | None):
+            self.name = name or "main"
+            self.external_id = external_id or "local-main"
+
+    @asynccontextmanager
+    async def fake_get_project_client(project=None, context=None, project_id=None):
+        yield object(), StubProject(project, project_id)
+
+    async def fake_resolve_project_and_path(client, identifier, project=None, context=None):
+        return StubProject(project, None), identifier, False
+
+    class FakeLogger:
+        def debug(self, *args, **kwargs):
+            pass
+
+        def error(self, *args, **kwargs):
+            pass
+
+        def warning(self, message, *args, **kwargs):
+            warnings.append(str(message))
+
+    class MockSearchClient:
+        def __init__(self, client, project_id):
+            self.project_id = project_id
+
+        async def search(self, payload, page, page_size):
+            if self.project_id == "22222222-2222-2222-2222-222222222222":
+                raise RuntimeError("team index unavailable")
+            return SearchResponse(
+                results=[
+                    SearchResult(
+                        title="Personal MCP Test Note",
+                        permalink="main/tests/mcp-test-note",
+                        content="MCP content",
+                        type=SearchItemType.ENTITY,
+                        score=0.5,
+                        file_path="/main/tests/mcp-test-note.md",
+                    )
+                ],
+                current_page=page,
+                page_size=page_size,
+                total=1,
+            )
+
+    monkeypatch.setattr(search_mod, "_load_search_project_refs", fake_load_search_project_refs)
+    monkeypatch.setattr(search_mod, "get_project_client", fake_get_project_client)
+    monkeypatch.setattr(search_mod, "resolve_project_and_path", fake_resolve_project_and_path)
+    monkeypatch.setattr(search_mod, "logger", FakeLogger())
+    monkeypatch.setattr(clients_mod, "SearchClient", MockSearchClient)
+
+    result = await search_mod.search_notes(
+        query="MCP Test Note",
+        search_all_projects=True,
+        output_format="json",
+    )
+
+    assert isinstance(result, dict)
+    assert [item["permalink"] for item in result["results"]] == [
+        "personal/main/tests/mcp-test-note",
+    ]
+    assert result["total"] == 1
+    assert any("team-paul/main" in warning for warning in warnings)
+    assert any("team index unavailable" in warning for warning in warnings)