perf fixes

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

Author: phernandez

src/basic_memory/mcp/project_context.py

@@ -64,6 +64,41 @@ async def _resolve_default_project_from_api() -> Optional[str]:
     return None
 
 
+async def _get_cached_active_project(context: Optional[Context]) -> Optional[ProjectItem]:
+    """Return the cached active project from context when available."""
+    if not context:
+        return None
+
+    cached_raw = await context.get_state("active_project")
+    if isinstance(cached_raw, dict):
+        return ProjectItem.model_validate(cached_raw)
+    return None
+
+
+async def _set_cached_active_project(
+    context: Optional[Context],
+    active_project: ProjectItem,
+) -> None:
+    """Persist the active project and known default-project metadata in context."""
+    if not context:
+        return
+
+    await context.set_state("active_project", active_project.model_dump())
+    if active_project.is_default:
+        await context.set_state("default_project_name", active_project.name)
+
+
+async def _get_cached_default_project(context: Optional[Context]) -> Optional[str]:
+    """Return the cached default project name from context when available."""
+    if not context:
+        return None
+
+    cached_default = await context.get_state("default_project_name")
+    if isinstance(cached_default, str):
+        return cached_default
+    return None
+
+
 def _canonicalize_project_name(
     project_name: Optional[str],
     config: BasicMemoryConfig,
@@ -85,11 +120,23 @@ def _canonicalize_project_name(
     return project_name
 
 
+def _project_matches_identifier(project_item: ProjectItem, identifier: Optional[str]) -> bool:
+    """Return True when the identifier refers to the cached project."""
+    if identifier is None:
+        return True
+
+    normalized_identifier = generate_permalink(identifier)
+    return normalized_identifier in {
+        generate_permalink(project_item.name),
+        project_item.permalink,
+    }
+
 
 async def resolve_project_parameter(
     project: Optional[str] = None,
     allow_discovery: bool = False,
     default_project: Optional[str] = None,
+    context: Optional[Context] = None,
 ) -> Optional[str]:
     """Resolve project parameter using unified linear priority chain.
 
@@ -119,14 +166,32 @@ async def resolve_project_parameter(
     ):
         config = ConfigManager().config
 
-        # Load config for any values not explicitly provided.
-        # ConfigManager reads from the local config file, which doesn't exist in cloud mode.
-        # When it returns None, fall back to querying the projects API for the is_default flag.
-        if default_project is None:
+        # Trigger: project already resolved earlier in the same MCP request
+        # Why: the active project is request-constant, so re-discovering the
+        #   default project via /v2/projects/ just repeats work
+        # Outcome: reuse the cached project name as the explicit candidate
+        if project is None:
+            cached_project = await _get_cached_active_project(context)
+            if cached_project is not None:
+                project = cached_project.name
+
+        # Trigger: there is no explicit project after env/context normalization
+        # Why: default-project discovery is only needed as a fallback; doing it
+        #   for explicit requests adds an avoidable /v2/projects/ round-trip
+        # Outcome: skip default lookup when the active project is already known
+        if default_project is None and project is None:
+            # Load config for any values not explicitly provided.
+            # ConfigManager reads from the local config file, which doesn't exist in cloud mode.
+            # When it returns None, fall back to querying the projects API for the is_default flag.
             default_project = config.default_project
 
-        if default_project is None:
-            default_project = await _resolve_default_project_from_api()
+            if default_project is None:
+                default_project = await _get_cached_default_project(context)
+
+            if default_project is None:
+                default_project = await _resolve_default_project_from_api()
+                if default_project and context:
+                    await context.set_state("default_project_name", default_project)
 
         # Create resolver with configuration and resolve
         resolver = ProjectResolver.from_env(
@@ -290,7 +355,12 @@ async def get_active_project(
         # Deferred import to avoid circular dependency with tools
         from basic_memory.mcp.tools.utils import call_post
 
-        resolved_project = await resolve_project_parameter(project)
+        cached_project = await _get_cached_active_project(context)
+        if cached_project and _project_matches_identifier(cached_project, project):
+            logger.debug(f"Using cached project from context: {cached_project.name}")
+            return cached_project
+
+        resolved_project = await resolve_project_parameter(project, context=context)
         if not resolved_project:
             project_names = await get_project_names(client, headers)
             raise ValueError(
@@ -301,14 +371,9 @@ async def get_active_project(
 
         project = resolved_project
 
-        # Check if already cached in context
-        if context:
-            cached_raw = await context.get_state("active_project")
-            if isinstance(cached_raw, dict):
-                cached_project = ProjectItem.model_validate(cached_raw)
-                if cached_project.name == project:
-                    logger.debug(f"Using cached project from context: {project}")
-                    return cached_project
+        if cached_project and _project_matches_identifier(cached_project, project):
+            logger.debug(f"Using cached project from context: {cached_project.name}")
+            return cached_project
 
         # Validate project exists by calling API
         logger.debug(f"Validating project: {project}")
@@ -328,8 +393,8 @@ async def get_active_project(
         )
 
         # Cache in context if available
+        await _set_cached_active_project(context, active_project)
         if context:
-            await context.set_state("active_project", active_project.model_dump())
             logger.debug(f"Cached project in context: {project}")
 
         logger.debug(f"Validated project: {active_project.name}")
@@ -383,6 +448,21 @@ async def resolve_project_and_path(
         # Why: allow project-scoped memory URLs without requiring a separate project parameter
         # Outcome: attempt to resolve the prefix as a project and route to it
         if project_prefix:
+            cached_project = await _get_cached_active_project(context)
+            if cached_project and _project_matches_identifier(cached_project, project_prefix):
+                resolved_project = await resolve_project_parameter(project_prefix, context=context)
+                if resolved_project and generate_permalink(resolved_project) != generate_permalink(
+                    project_prefix
+                ):
+                    raise ValueError(
+                        f"Project is constrained to '{resolved_project}', cannot use '{project_prefix}'."
+                    )
+
+                resolved_path = (
+                    f"{cached_project.permalink}/{remainder}" if include_project else remainder
+                )
+                return cached_project, resolved_path, True
+
             try:
                 from basic_memory.mcp.tools.utils import call_post
 
@@ -397,7 +477,7 @@ async def resolve_project_and_path(
                 if "project not found" not in str(exc).lower():
                     raise
             else:
-                resolved_project = await resolve_project_parameter(project_prefix)
+                resolved_project = await resolve_project_parameter(project_prefix, context=context)
                 if resolved_project and generate_permalink(resolved_project) != generate_permalink(
                     project_prefix
                 ):
@@ -412,8 +492,7 @@ async def resolve_project_and_path(
                     path=resolved.path,
                     is_default=resolved.is_default,
                 )
-                if context:
-                    await context.set_state("active_project", active_project.model_dump())
+                await _set_cached_active_project(context, active_project)
 
                 resolved_path = (
                     f"{resolved.permalink}/{remainder}" if include_project else remainder
@@ -530,7 +609,7 @@ async def get_project_client(
     )
 
     # Step 1: Resolve project name from config (no network call)
-    resolved_project = await resolve_project_parameter(project)
+    resolved_project = await resolve_project_parameter(project, context=context)
     if not resolved_project:
         # Fall back to local client to discover projects and raise helpful error
         async with get_client() as client:

src/basic_memory/sync/sync_service.py

@@ -350,7 +350,9 @@ async def sync(
             # Only resolve relations if there were actual changes
             # If no files changed, no new unresolved relations could have been created
             if report.total > 0:
-                with telemetry.scope("sync.project.resolve_relations", relation_scope="all_pending"):
+                with telemetry.scope(
+                    "sync.project.resolve_relations", relation_scope="all_pending"
+                ):
                     await self.resolve_relations()
             else:
                 logger.info("Skipping relation resolution - no file changes detected")

tests/mcp/test_project_context.py

@@ -311,6 +311,169 @@ async def fail_if_called(context=None):  # pragma: no cover
     assert resolved.tenant_id == cached_workspace.tenant_id
 
 
+@pytest.mark.asyncio
+async def test_resolve_project_parameter_uses_cached_active_project_before_api_default_lookup(
+    config_manager, monkeypatch
+):
+    from basic_memory.mcp.project_context import resolve_project_parameter
+    from basic_memory.schemas.project_info import ProjectItem
+
+    config = config_manager.load_config()
+    config.default_project = None
+    config_manager.save_config(config)
+
+    context = _ContextState()
+    cached_project = ProjectItem(
+        id=1,
+        external_id="11111111-1111-1111-1111-111111111111",
+        name="Cached Project",
+        path="/tmp/cached-project",
+        is_default=True,
+    )
+    await context.set_state("active_project", cached_project.model_dump())
+
+    async def fail_if_called():  # pragma: no cover
+        raise AssertionError("Default project API lookup should not run when project is cached")
+
+    monkeypatch.setattr(
+        "basic_memory.mcp.project_context._resolve_default_project_from_api",
+        fail_if_called,
+    )
+
+    resolved = await resolve_project_parameter(project=None, context=context)
+    assert resolved == cached_project.name
+
+
+@pytest.mark.asyncio
+async def test_resolve_project_parameter_caches_api_default_project_name(
+    config_manager, monkeypatch
+):
+    from basic_memory.mcp.project_context import resolve_project_parameter
+
+    config = config_manager.load_config()
+    config.default_project = None
+    config_manager.save_config(config)
+
+    context = _ContextState()
+    api_calls = {"count": 0}
+
+    async def fake_default_lookup():
+        api_calls["count"] += 1
+        return "cloud-default"
+
+    monkeypatch.setattr(
+        "basic_memory.mcp.project_context._resolve_default_project_from_api",
+        fake_default_lookup,
+    )
+
+    first = await resolve_project_parameter(project=None, context=context)
+    second = await resolve_project_parameter(project=None, context=context)
+
+    assert first == "cloud-default"
+    assert second == "cloud-default"
+    assert api_calls["count"] == 1
+
+
+@pytest.mark.asyncio
+async def test_get_active_project_uses_cached_project_before_resolution(monkeypatch):
+    from basic_memory.mcp.project_context import get_active_project
+    from basic_memory.schemas.project_info import ProjectItem
+
+    context = _ContextState()
+    cached_project = ProjectItem(
+        id=1,
+        external_id="11111111-1111-1111-1111-111111111111",
+        name="Cached Project",
+        path="/tmp/cached-project",
+        is_default=True,
+    )
+    await context.set_state("active_project", cached_project.model_dump())
+
+    async def fail_if_called(*args, **kwargs):  # pragma: no cover
+        raise AssertionError("Project resolution should not run when cache matches")
+
+    monkeypatch.setattr(
+        "basic_memory.mcp.project_context.resolve_project_parameter",
+        fail_if_called,
+    )
+
+    resolved = await get_active_project(client=None, context=context)
+    assert resolved == cached_project
+
+
+@pytest.mark.asyncio
+async def test_get_active_project_uses_cached_project_for_explicit_permalink(monkeypatch):
+    from basic_memory.mcp.project_context import get_active_project
+    from basic_memory.schemas.project_info import ProjectItem
+
+    context = _ContextState()
+    cached_project = ProjectItem(
+        id=1,
+        external_id="11111111-1111-1111-1111-111111111111",
+        name="My Research",
+        path="/tmp/my-research",
+        is_default=False,
+    )
+    await context.set_state("active_project", cached_project.model_dump())
+
+    async def fail_if_called(*args, **kwargs):  # pragma: no cover
+        raise AssertionError(
+            "Project resolution should not run when explicit project matches cache"
+        )
+
+    monkeypatch.setattr(
+        "basic_memory.mcp.project_context.resolve_project_parameter",
+        fail_if_called,
+    )
+
+    resolved = await get_active_project(client=None, project="my-research", context=context)
+    assert resolved == cached_project
+
+
+@pytest.mark.asyncio
+async def test_resolve_project_and_path_uses_cached_project_for_memory_url_prefix(
+    config_manager, monkeypatch
+):
+    from basic_memory.mcp.project_context import resolve_project_and_path
+    from basic_memory.schemas.project_info import ProjectItem
+
+    config = config_manager.load_config()
+    config.permalinks_include_project = False
+    config_manager.save_config(config)
+
+    context = _ContextState()
+    cached_project = ProjectItem(
+        id=1,
+        external_id="11111111-1111-1111-1111-111111111111",
+        name="My Research",
+        path="/tmp/my-research",
+        is_default=False,
+    )
+    await context.set_state("active_project", cached_project.model_dump())
+
+    async def fail_if_called(*args, **kwargs):  # pragma: no cover
+        raise AssertionError("Project resolve API should not run when memory URL matches cache")
+
+    async def fake_resolve_project_parameter(project=None, **kwargs):
+        return cached_project.name if project else cached_project.name
+
+    monkeypatch.setattr("basic_memory.mcp.tools.utils.call_post", fail_if_called)
+    monkeypatch.setattr(
+        "basic_memory.mcp.project_context.resolve_project_parameter",
+        fake_resolve_project_parameter,
+    )
+
+    active_project, resolved_path, is_memory_url = await resolve_project_and_path(
+        client=None,
+        identifier="memory://my-research/notes/roadmap.md",
+        context=context,
+    )
+
+    assert active_project == cached_project
+    assert resolved_path == "notes/roadmap.md"
+    assert is_memory_url is True
+
+
 @pytest.mark.asyncio
 async def test_get_project_client_rejects_workspace_for_local_project(config_manager):
     from basic_memory.mcp.project_context import get_project_client
@@ -383,7 +546,6 @@ def test_matches_case_insensitive_via_permalink(self, config_manager):
         assert result == "My Research"
 
 
-
 class TestGetProjectClientRoutingOrder:
     """Test that get_project_client respects explicit routing before workspace resolution."""