feat: improve mcp log clarity

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

Author: phernandez

src/basic_memory/mcp/project_context.py

@@ -85,6 +85,22 @@ def _canonicalize_project_name(
     return project_name
 
 
+def _configured_project_name(
+    project_name: Optional[str],
+    config: BasicMemoryConfig,
+) -> Optional[str]:
+    """Return the configured project name when the identifier matches a known project."""
+    if project_name is None:
+        return None
+
+    requested_permalink = generate_permalink(project_name)
+    for configured_name in config.projects:
+        if generate_permalink(configured_name) == requested_permalink:
+            return configured_name
+
+    return None
+
+
 async def resolve_project_parameter(
     project: Optional[str] = None,
     allow_discovery: bool = False,
@@ -363,7 +379,8 @@ async def resolve_project_and_path(
         Tuple of (active_project, normalized_path, is_memory_url)
     """
     is_memory_url = identifier.strip().startswith("memory://")
-    include_project = ConfigManager().config.permalinks_include_project if is_memory_url else None
+    config = ConfigManager().config
+    include_project = config.permalinks_include_project if is_memory_url else None
     with telemetry.scope(
         "routing.resolve_memory_url",
         is_memory_url=is_memory_url,
@@ -376,12 +393,20 @@ async def resolve_project_and_path(
 
         normalized_path = normalize_project_reference(memory_url_path(identifier))
         project_prefix, remainder = _split_project_prefix(normalized_path)
-        include_project = ConfigManager().config.permalinks_include_project
+        include_project = config.permalinks_include_project
+        configured_prefix = _configured_project_name(project_prefix, config)
 
         # Trigger: memory URL begins with a potential project segment
         # 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:
+        #
+        # Trigger: the active project is already fixed and the first path segment is not
+        # a configured project name
+        # Why: in memory URLs like memory://notes/topic, "notes" is a directory, not a
+        # project. Resolving it through /v2/projects/resolve creates noisy false-negative
+        # logs before the tool recovers with the active project anyway.
+        # Outcome: skip project resolution and keep the path within the active project.
+        if project_prefix and (configured_prefix is not None or project is None):
             try:
                 from basic_memory.mcp.tools.utils import call_post
 

src/basic_memory/mcp/tools/build_context.py

@@ -223,15 +223,17 @@ async def build_context(
                 tool_name="build_context",
             ):
                 logger.info(
-                    "Building context",
-                    url=str(url),
-                    project=active_project.name,
-                    depth=depth,
-                    timeframe=timeframe,
+                    f"MCP tool call tool=build_context project={active_project.name} "
+                    f"url={url} depth={depth} timeframe={timeframe} output_format={output_format}"
                 )
 
                 # Resolve memory:// identifier with project-prefix awareness
-                _, resolved_path, _ = await resolve_project_and_path(client, url, project, context)
+                _, resolved_path, _ = await resolve_project_and_path(
+                    client,
+                    url,
+                    active_project.name,
+                    context,
+                )
 
                 # Import here to avoid circular import
                 from basic_memory.mcp.clients import MemoryClient
@@ -247,6 +249,14 @@ async def build_context(
                     max_related=max_related,
                 )
 
+                logger.info(
+                    f"MCP tool response: tool=build_context project={active_project.name} "
+                    f"uri={graph.metadata.uri or resolved_path} "
+                    f"primary_count={graph.metadata.primary_count or 0} "
+                    f"related_count={graph.metadata.related_count or 0} "
+                    f"output_format={output_format}"
+                )
+
                 if output_format == "text":
                     return _format_context_markdown(graph, active_project.name)
 

src/basic_memory/mcp/tools/edit_note.py

@@ -290,11 +290,8 @@ async def edit_note(
                 tool_name="edit_note",
             ):
                 logger.info(
-                    "MCP tool call",
-                    tool="edit_note",
-                    project=active_project.name,
-                    identifier=identifier,
-                    operation=operation,
+                    f"MCP tool call tool=edit_note project={active_project.name} "
+                    f"identifier={identifier} operation={operation} output_format={output_format}"
                 )
 
                 # Validate operation
@@ -474,14 +471,11 @@ async def edit_note(
                             summary.append(f"- Unresolved: {unresolved}")
 
                     logger.info(
-                        "MCP tool response",
-                        tool="edit_note",
-                        operation=operation,
-                        project=active_project.name,
-                        permalink=result.permalink,
-                        observations_count=len(result.observations),
-                        relations_count=len(result.relations),
-                        file_created=file_created,
+                        f"MCP tool response: tool=edit_note project={active_project.name} "
+                        f"operation={operation} permalink={result.permalink} "
+                        f"observations_count={len(result.observations)} "
+                        f"relations_count={len(result.relations)} "
+                        f"file_created={str(file_created).lower()}"
                     )
 
                     if output_format == "json":

src/basic_memory/mcp/tools/move_note.py

@@ -477,8 +477,11 @@ async def move_note(
             }
         return f"# Move Failed - Invalid Parameters\n\n{error_msg}"
     async with get_project_client(project, workspace, context) as (client, active_project):
-        logger.debug(
-            f"Moving {'directory' if is_directory else 'note'}: {identifier} to {destination_path} in project: {active_project.name}"
+        destination_target = destination_folder or destination_path
+        logger.info(
+            f"MCP tool call tool=move_note project={active_project.name} "
+            f"identifier={identifier} destination={destination_target} "
+            f"is_directory={str(is_directory).lower()}"
         )
 
         # Validate destination path to prevent path traversal attacks
@@ -834,10 +837,8 @@ async def _ensure_resolved_entity_id() -> str:
 
             # Log the operation
             logger.info(
-                "Move note completed",
-                identifier=identifier,
-                destination_path=destination_path,
-                project=active_project.name,
+                f"MCP tool response: tool=move_note project={active_project.name} "
+                f"source={identifier} destination={result.file_path} permalink={result.permalink}"
             )
 
             return "\n".join(result_lines)

src/basic_memory/mcp/tools/read_content.py

@@ -216,7 +216,7 @@ async def read_content(
         if detected:
             project = detected
 
-    logger.info("Reading file", path=path, project=project)
+    logger.info(f"MCP tool call tool=read_content project={project} path={path}")
 
     async with get_project_client(project, workspace, context) as (client, active_project):
         # Resolve path with project-prefix awareness for memory:// URLs
@@ -260,6 +260,10 @@ async def read_content(
         # Handle text or json
         if content_type.startswith("text/") or content_type == "application/json":
             logger.debug("Processing text resource")
+            logger.info(
+                f"MCP tool response: tool=read_content project={active_project.name} "
+                f"path={url} type=text content_type={content_type}"
+            )
             return {
                 "type": "text",
                 "text": response.text,
@@ -272,6 +276,10 @@ async def read_content(
             logger.debug("Processing image")
             img = PILImage.open(io.BytesIO(response.content))
             img_bytes = optimize_image(img, content_length)
+            logger.info(
+                f"MCP tool response: tool=read_content project={active_project.name} "
+                f"path={url} type=image content_type=image/jpeg"
+            )
 
             return {
                 "type": "image",
@@ -291,6 +299,10 @@ async def read_content(
                     "type": "error",
                     "error": f"Document size {content_length} bytes exceeds maximum allowed size",
                 }
+            logger.info(
+                f"MCP tool response: tool=read_content project={active_project.name} "
+                f"path={url} type=document content_type={content_type}"
+            )
             return {
                 "type": "document",
                 "source": {

src/basic_memory/mcp/tools/search.py

@@ -634,7 +634,13 @@ async def search_notes(
                     if not search_query.entity_types:
                         search_query.entity_types = [SearchItemType("entity")]
 
-                    logger.debug(f"Searching for {search_query} in project {active_project.name}")
+                    logger.debug(
+                        f"Search request: project={active_project.name} "
+                        f"search_type={effective_search_type} "
+                        f"query={effective_query or '<filters-only>'} "
+                        f"note_types={len(note_types)} entity_types={len(search_query.entity_types or [])} "
+                        f"page={page} page_size={page_size}"
+                    )
                     # Import here to avoid circular import (tools → clients → utils → tools)
                     from basic_memory.mcp.clients import SearchClient
 
@@ -645,6 +651,11 @@ async def search_notes(
                         page=page,
                         page_size=page_size,
                     )
+                    logger.debug(
+                        f"Search response: project={active_project.name} "
+                        f"results={len(result.results)} has_more={str(result.has_more).lower()} "
+                        f"page={result.current_page} page_size={result.page_size}"
+                    )
 
                     # Check if we got no results and provide helpful guidance
                     if not result.results:

tests/mcp/test_project_context.py

@@ -383,6 +383,49 @@ def test_matches_case_insensitive_via_permalink(self, config_manager):
         assert result == "My Research"
 
 
+@pytest.mark.asyncio
+async def test_resolve_project_and_path_skips_unknown_prefix_when_project_already_fixed(
+    config_manager, monkeypatch
+):
+    from basic_memory.mcp.project_context import ProjectItem, resolve_project_and_path
+
+    config = config_manager.load_config()
+    config.permalinks_include_project = True
+    config_manager.save_config(config)
+
+    async def fake_get_active_project(client, project=None, context=None, headers=None):
+        return ProjectItem(
+            id=1,
+            external_id="project-123",
+            name="test-project",
+            path="/tmp/test-project",
+            is_default=True,
+        )
+
+    async def fail_if_called(*args, **kwargs):  # pragma: no cover
+        raise AssertionError("Project resolution should not run for a plain directory prefix")
+
+    monkeypatch.setattr(
+        "basic_memory.mcp.project_context.get_active_project",
+        fake_get_active_project,
+    )
+    monkeypatch.setattr(
+        "basic_memory.mcp.tools.utils.call_post",
+        fail_if_called,
+    )
+
+    active_project, resolved_path, is_memory_url = await resolve_project_and_path(
+        client=object(),
+        identifier="memory://testing/note",
+        project="test-project",
+        context=None,
+    )
+
+    assert active_project.name == "test-project"
+    assert resolved_path == "test-project/testing/note"
+    assert is_memory_url is True
+
+
 class TestGetProjectClientRoutingOrder:
     """Test that get_project_client respects explicit routing before workspace resolution."""