basic-memory 0.15.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

basic_memory/mcp/tools/project_management.py

@@ -7,7 +7,7 @@ and manage project context during conversations.
 import os
 from fastmcp import Context
 
-from basic_memory.mcp.async_client import client
+from basic_memory.mcp.async_client import get_client
 from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.utils import call_get, call_post, call_delete
 from basic_memory.schemas.project_info import (
@@ -40,34 +40,35 @@ async def list_memory_projects(context: Context | None = None) -> str:
     Example:
         list_memory_projects()
     """
-    if context:  # pragma: no cover
-        await context.info("Listing all available projects")
+    async with get_client() as client:
+        if context:  # pragma: no cover
+            await context.info("Listing all available projects")
 
-    # Check if server is constrained to a specific project
-    constrained_project = os.environ.get("BASIC_MEMORY_MCP_PROJECT")
+        # Check if server is constrained to a specific project
+        constrained_project = os.environ.get("BASIC_MEMORY_MCP_PROJECT")
 
-    # Get projects from API
-    response = await call_get(client, "/projects/projects")
-    project_list = ProjectList.model_validate(response.json())
+        # Get projects from API
+        response = await call_get(client, "/projects/projects")
+        project_list = ProjectList.model_validate(response.json())
 
-    if constrained_project:
-        result = f"Project: {constrained_project}\n\n"
-        result += "Note: This MCP server is constrained to a single project.\n"
-        result += "All operations will automatically use this project."
-    else:
-        # Show all projects with session guidance
-        result = "Available projects:\n"
+        if constrained_project:
+            result = f"Project: {constrained_project}\n\n"
+            result += "Note: This MCP server is constrained to a single project.\n"
+            result += "All operations will automatically use this project."
+        else:
+            # Show all projects with session guidance
+            result = "Available projects:\n"
 
-        for project in project_list.projects:
-            result += f"• {project.name}\n"
+            for project in project_list.projects:
+                result += f"• {project.name}\n"
 
-        result += "\n" + "─" * 40 + "\n"
-        result += "Next: Ask which project to use for this session.\n"
-        result += "Example: 'Which project should I use for this task?'\n\n"
-        result += "Session reminder: Track the selected project for all subsequent operations in this conversation.\n"
-        result += "The user can say 'switch to [project]' to change projects."
+            result += "\n" + "─" * 40 + "\n"
+            result += "Next: Ask which project to use for this session.\n"
+            result += "Example: 'Which project should I use for this task?'\n\n"
+            result += "Session reminder: Track the selected project for all subsequent operations in this conversation.\n"
+            result += "The user can say 'switch to [project]' to change projects."
 
-    return result
+        return result
 
 
 @mcp.tool("create_memory_project")
@@ -91,37 +92,38 @@ async def create_memory_project(
         create_memory_project("my-research", "~/Documents/research")
         create_memory_project("work-notes", "/home/user/work", set_default=True)
     """
-    # Check if server is constrained to a specific project
-    constrained_project = os.environ.get("BASIC_MEMORY_MCP_PROJECT")
-    if constrained_project:
-        return f'# Error\n\nProject creation disabled - MCP server is constrained to project \'{constrained_project}\'.\nUse the CLI to create projects: `basic-memory project add "{project_name}" "{project_path}"`'
-
-    if context:  # pragma: no cover
-        await context.info(f"Creating project: {project_name} at {project_path}")
-
-    # Create the project request
-    project_request = ProjectInfoRequest(
-        name=project_name, path=project_path, set_default=set_default
-    )
+    async with get_client() as client:
+        # Check if server is constrained to a specific project
+        constrained_project = os.environ.get("BASIC_MEMORY_MCP_PROJECT")
+        if constrained_project:
+            return f'# Error\n\nProject creation disabled - MCP server is constrained to project \'{constrained_project}\'.\nUse the CLI to create projects: `basic-memory project add "{project_name}" "{project_path}"`'
+
+        if context:  # pragma: no cover
+            await context.info(f"Creating project: {project_name} at {project_path}")
+
+        # Create the project request
+        project_request = ProjectInfoRequest(
+            name=project_name, path=project_path, set_default=set_default
+        )
 
-    # Call API to create project
-    response = await call_post(client, "/projects/projects", json=project_request.model_dump())
-    status_response = ProjectStatusResponse.model_validate(response.json())
+        # Call API to create project
+        response = await call_post(client, "/projects/projects", json=project_request.model_dump())
+        status_response = ProjectStatusResponse.model_validate(response.json())
 
-    result = f"✓ {status_response.message}\n\n"
+        result = f"✓ {status_response.message}\n\n"
 
-    if status_response.new_project:
-        result += "Project Details:\n"
-        result += f"• Name: {status_response.new_project.name}\n"
-        result += f"• Path: {status_response.new_project.path}\n"
+        if status_response.new_project:
+            result += "Project Details:\n"
+            result += f"• Name: {status_response.new_project.name}\n"
+            result += f"• Path: {status_response.new_project.path}\n"
 
-        if set_default:
-            result += "• Set as default project\n"
+            if set_default:
+                result += "• Set as default project\n"
 
-    result += "\nProject is now available for use in tool calls.\n"
-    result += f"Use '{project_name}' as the project parameter in MCP tool calls.\n"
+        result += "\nProject is now available for use in tool calls.\n"
+        result += f"Use '{project_name}' as the project parameter in MCP tool calls.\n"
 
-    return result
+        return result
 
 
 @mcp.tool()
@@ -145,53 +147,54 @@ async def delete_project(project_name: str, context: Context | None = None) -> s
         This action cannot be undone. The project will need to be re-added
         to access its content through Basic Memory again.
     """
-    # Check if server is constrained to a specific project
-    constrained_project = os.environ.get("BASIC_MEMORY_MCP_PROJECT")
-    if constrained_project:
-        return f"# Error\n\nProject deletion disabled - MCP server is constrained to project '{constrained_project}'.\nUse the CLI to delete projects: `basic-memory project remove \"{project_name}\"`"
-
-    if context:  # pragma: no cover
-        await context.info(f"Deleting project: {project_name}")
-
-    # Get project info before deletion to validate it exists
-    response = await call_get(client, "/projects/projects")
-    project_list = ProjectList.model_validate(response.json())
-
-    # Find the project by name (case-insensitive) or permalink - same logic as switch_project
-    project_permalink = generate_permalink(project_name)
-    target_project = None
-    for p in project_list.projects:
-        # Match by permalink (handles case-insensitive input)
-        if p.permalink == project_permalink:
-            target_project = p
-            break
-        # Also match by name comparison (case-insensitive)
-        if p.name.lower() == project_name.lower():
-            target_project = p
-            break
-
-    if not target_project:
-        available_projects = [p.name for p in project_list.projects]
-        raise ValueError(
-            f"Project '{project_name}' not found. Available projects: {', '.join(available_projects)}"
-        )
-
-    # Call API to delete project using URL encoding for special characters
-    from urllib.parse import quote
-
-    encoded_name = quote(target_project.name, safe="")
-    response = await call_delete(client, f"/projects/{encoded_name}")
-    status_response = ProjectStatusResponse.model_validate(response.json())
-
-    result = f"✓ {status_response.message}\n\n"
-
-    if status_response.old_project:
-        result += "Removed project details:\n"
-        result += f"• Name: {status_response.old_project.name}\n"
-        if hasattr(status_response.old_project, "path"):
-            result += f"• Path: {status_response.old_project.path}\n"
-
-    result += "Files remain on disk but project is no longer tracked by Basic Memory.\n"
-    result += "Re-add the project to access its content again.\n"
-
-    return result
+    async with get_client() as client:
+        # Check if server is constrained to a specific project
+        constrained_project = os.environ.get("BASIC_MEMORY_MCP_PROJECT")
+        if constrained_project:
+            return f"# Error\n\nProject deletion disabled - MCP server is constrained to project '{constrained_project}'.\nUse the CLI to delete projects: `basic-memory project remove \"{project_name}\"`"
+
+        if context:  # pragma: no cover
+            await context.info(f"Deleting project: {project_name}")
+
+        # Get project info before deletion to validate it exists
+        response = await call_get(client, "/projects/projects")
+        project_list = ProjectList.model_validate(response.json())
+
+        # Find the project by name (case-insensitive) or permalink - same logic as switch_project
+        project_permalink = generate_permalink(project_name)
+        target_project = None
+        for p in project_list.projects:
+            # Match by permalink (handles case-insensitive input)
+            if p.permalink == project_permalink:
+                target_project = p
+                break
+            # Also match by name comparison (case-insensitive)
+            if p.name.lower() == project_name.lower():
+                target_project = p
+                break
+
+        if not target_project:
+            available_projects = [p.name for p in project_list.projects]
+            raise ValueError(
+                f"Project '{project_name}' not found. Available projects: {', '.join(available_projects)}"
+            )
+
+        # Call API to delete project using URL encoding for special characters
+        from urllib.parse import quote
+
+        encoded_name = quote(target_project.name, safe="")
+        response = await call_delete(client, f"/projects/{encoded_name}")
+        status_response = ProjectStatusResponse.model_validate(response.json())
+
+        result = f"✓ {status_response.message}\n\n"
+
+        if status_response.old_project:
+            result += "Removed project details:\n"
+            result += f"• Name: {status_response.old_project.name}\n"
+            if hasattr(status_response.old_project, "path"):
+                result += f"• Path: {status_response.old_project.path}\n"
+
+        result += "Files remain on disk but project is no longer tracked by Basic Memory.\n"
+        result += "Re-add the project to access its content again.\n"
+
+        return result

basic_memory/mcp/tools/read_content.py

@@ -16,7 +16,7 @@ from fastmcp import Context
 
 from basic_memory.mcp.project_context import get_active_project
 from basic_memory.mcp.server import mcp
-from basic_memory.mcp.async_client import client
+from basic_memory.mcp.async_client import get_client
 from basic_memory.mcp.tools.utils import call_get
 from basic_memory.schemas.memory import memory_url_path
 from basic_memory.utils import validate_project_path
@@ -201,70 +201,71 @@ async def read_content(
     """
     logger.info("Reading file", path=path, project=project)
 
-    active_project = await get_active_project(client, project, context)
-    project_url = active_project.project_url
+    async with get_client() as client:
+        active_project = await get_active_project(client, project, context)
+        project_url = active_project.project_url
 
-    url = memory_url_path(path)
+        url = memory_url_path(path)
 
-    # Validate path to prevent path traversal attacks
-    project_path = active_project.home
-    if not validate_project_path(url, project_path):
-        logger.warning(
-            "Attempted path traversal attack blocked",
-            path=path,
-            url=url,
-            project=active_project.name,
-        )
-        return {
-            "type": "error",
-            "error": f"Path '{path}' is not allowed - paths must stay within project boundaries",
-        }
-
-    response = await call_get(client, f"{project_url}/resource/{url}")
-    content_type = response.headers.get("content-type", "application/octet-stream")
-    content_length = int(response.headers.get("content-length", 0))
-
-    logger.debug("Resource metadata", content_type=content_type, size=content_length, path=path)
-
-    # Handle text or json
-    if content_type.startswith("text/") or content_type == "application/json":
-        logger.debug("Processing text resource")
-        return {
-            "type": "text",
-            "text": response.text,
-            "content_type": content_type,
-            "encoding": "utf-8",
-        }
-
-    # Handle images
-    elif content_type.startswith("image/"):
-        logger.debug("Processing image")
-        img = PILImage.open(io.BytesIO(response.content))
-        img_bytes = optimize_image(img, content_length)
-
-        return {
-            "type": "image",
-            "source": {
-                "type": "base64",
-                "media_type": "image/jpeg",
-                "data": base64.b64encode(img_bytes).decode("utf-8"),
-            },
-        }
-
-    # Handle other file types
-    else:
-        logger.debug(f"Processing binary resource content_type {content_type}")
-        if content_length > 350000:  # pragma: no cover
-            logger.warning("Document too large for response", size=content_length)
+        # Validate path to prevent path traversal attacks
+        project_path = active_project.home
+        if not validate_project_path(url, project_path):
+            logger.warning(
+                "Attempted path traversal attack blocked",
+                path=path,
+                url=url,
+                project=active_project.name,
+            )
             return {
                 "type": "error",
-                "error": f"Document size {content_length} bytes exceeds maximum allowed size",
+                "error": f"Path '{path}' is not allowed - paths must stay within project boundaries",
+            }
+
+        response = await call_get(client, f"{project_url}/resource/{url}")
+        content_type = response.headers.get("content-type", "application/octet-stream")
+        content_length = int(response.headers.get("content-length", 0))
+
+        logger.debug("Resource metadata", content_type=content_type, size=content_length, path=path)
+
+        # Handle text or json
+        if content_type.startswith("text/") or content_type == "application/json":
+            logger.debug("Processing text resource")
+            return {
+                "type": "text",
+                "text": response.text,
+                "content_type": content_type,
+                "encoding": "utf-8",
+            }
+
+        # Handle images
+        elif content_type.startswith("image/"):
+            logger.debug("Processing image")
+            img = PILImage.open(io.BytesIO(response.content))
+            img_bytes = optimize_image(img, content_length)
+
+            return {
+                "type": "image",
+                "source": {
+                    "type": "base64",
+                    "media_type": "image/jpeg",
+                    "data": base64.b64encode(img_bytes).decode("utf-8"),
+                },
+            }
+
+        # Handle other file types
+        else:
+            logger.debug(f"Processing binary resource content_type {content_type}")
+            if content_length > 350000:  # pragma: no cover
+                logger.warning("Document too large for response", size=content_length)
+                return {
+                    "type": "error",
+                    "error": f"Document size {content_length} bytes exceeds maximum allowed size",
+                }
+            return {
+                "type": "document",
+                "source": {
+                    "type": "base64",
+                    "media_type": content_type,
+                    "data": base64.b64encode(response.content).decode("utf-8"),
+                },
             }
-        return {
-            "type": "document",
-            "source": {
-                "type": "base64",
-                "media_type": content_type,
-                "data": base64.b64encode(response.content).decode("utf-8"),
-            },
-        }

basic_memory/mcp/tools/read_note.py

@@ -6,7 +6,7 @@ from typing import Optional
 from loguru import logger
 from fastmcp import Context
 
-from basic_memory.mcp.async_client import client
+from basic_memory.mcp.async_client import get_client
 from basic_memory.mcp.project_context import get_active_project
 from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.search import search_notes
@@ -77,96 +77,96 @@ async def read_note(
         If the exact note isn't found, this tool provides helpful suggestions
         including related notes, search commands, and note creation templates.
     """
-
-    # Get and validate the project
-    active_project = await get_active_project(client, project, context)
-
-    # Validate identifier to prevent path traversal attacks
-    # We need to check both the raw identifier and the processed path
-    processed_path = memory_url_path(identifier)
-    project_path = active_project.home
-
-    if not validate_project_path(identifier, project_path) or not validate_project_path(
-        processed_path, project_path
-    ):
-        logger.warning(
-            "Attempted path traversal attack blocked",
-            identifier=identifier,
-            processed_path=processed_path,
-            project=active_project.name,
+    async with get_client() as client:
+        # Get and validate the project
+        active_project = await get_active_project(client, project, context)
+
+        # Validate identifier to prevent path traversal attacks
+        # We need to check both the raw identifier and the processed path
+        processed_path = memory_url_path(identifier)
+        project_path = active_project.home
+
+        if not validate_project_path(identifier, project_path) or not validate_project_path(
+            processed_path, project_path
+        ):
+            logger.warning(
+                "Attempted path traversal attack blocked",
+                identifier=identifier,
+                processed_path=processed_path,
+                project=active_project.name,
+            )
+            return f"# Error\n\nIdentifier '{identifier}' is not allowed - paths must stay within project boundaries"
+
+        # Check migration status and wait briefly if needed
+        from basic_memory.mcp.tools.utils import wait_for_migration_or_return_status
+
+        migration_status = await wait_for_migration_or_return_status(
+            timeout=5.0, project_name=active_project.name
+        )
+        if migration_status:  # pragma: no cover
+            return f"# System Status\n\n{migration_status}\n\nPlease wait for migration to complete before reading notes."
+        project_url = active_project.project_url
+
+        # Get the file via REST API - first try direct permalink lookup
+        entity_path = memory_url_path(identifier)
+        path = f"{project_url}/resource/{entity_path}"
+        logger.info(f"Attempting to read note from Project: {active_project.name} URL: {path}")
+
+        try:
+            # Try direct lookup first
+            response = await call_get(client, path, params={"page": page, "page_size": page_size})
+
+            # If successful, return the content
+            if response.status_code == 200:
+                logger.info("Returning read_note result from resource: {path}", path=entity_path)
+                return response.text
+        except Exception as e:  # pragma: no cover
+            logger.info(f"Direct lookup failed for '{path}': {e}")
+            # Continue to fallback methods
+
+        # Fallback 1: Try title search via API
+        logger.info(f"Search title for: {identifier}")
+        title_results = await search_notes.fn(
+            query=identifier, search_type="title", project=project, context=context
         )
-        return f"# Error\n\nIdentifier '{identifier}' is not allowed - paths must stay within project boundaries"
-
-    # Check migration status and wait briefly if needed
-    from basic_memory.mcp.tools.utils import wait_for_migration_or_return_status
-
-    migration_status = await wait_for_migration_or_return_status(
-        timeout=5.0, project_name=active_project.name
-    )
-    if migration_status:  # pragma: no cover
-        return f"# System Status\n\n{migration_status}\n\nPlease wait for migration to complete before reading notes."
-    project_url = active_project.project_url
-
-    # Get the file via REST API - first try direct permalink lookup
-    entity_path = memory_url_path(identifier)
-    path = f"{project_url}/resource/{entity_path}"
-    logger.info(f"Attempting to read note from Project: {active_project.name} URL: {path}")
-
-    try:
-        # Try direct lookup first
-        response = await call_get(client, path, params={"page": page, "page_size": page_size})
-
-        # If successful, return the content
-        if response.status_code == 200:
-            logger.info("Returning read_note result from resource: {path}", path=entity_path)
-            return response.text
-    except Exception as e:  # pragma: no cover
-        logger.info(f"Direct lookup failed for '{path}': {e}")
-        # Continue to fallback methods
-
-    # Fallback 1: Try title search via API
-    logger.info(f"Search title for: {identifier}")
-    title_results = await search_notes.fn(
-        query=identifier, search_type="title", project=project, context=context
-    )
-
-    # Handle both SearchResponse object and error strings
-    if title_results and hasattr(title_results, "results") and title_results.results:
-        result = title_results.results[0]  # Get the first/best match
-        if result.permalink:
-            try:
-                # Try to fetch the content using the found permalink
-                path = f"{project_url}/resource/{result.permalink}"
-                response = await call_get(
-                    client, path, params={"page": page, "page_size": page_size}
-                )
-
-                if response.status_code == 200:
-                    logger.info(f"Found note by title search: {result.permalink}")
-                    return response.text
-            except Exception as e:  # pragma: no cover
-                logger.info(
-                    f"Failed to fetch content for found title match {result.permalink}: {e}"
-                )
-    else:
-        logger.info(
-            f"No results in title search for: {identifier} in project {active_project.name}"
+
+        # Handle both SearchResponse object and error strings
+        if title_results and hasattr(title_results, "results") and title_results.results:
+            result = title_results.results[0]  # Get the first/best match
+            if result.permalink:
+                try:
+                    # Try to fetch the content using the found permalink
+                    path = f"{project_url}/resource/{result.permalink}"
+                    response = await call_get(
+                        client, path, params={"page": page, "page_size": page_size}
+                    )
+
+                    if response.status_code == 200:
+                        logger.info(f"Found note by title search: {result.permalink}")
+                        return response.text
+                except Exception as e:  # pragma: no cover
+                    logger.info(
+                        f"Failed to fetch content for found title match {result.permalink}: {e}"
+                    )
+        else:
+            logger.info(
+                f"No results in title search for: {identifier} in project {active_project.name}"
+            )
+
+        # Fallback 2: Text search as a last resort
+        logger.info(f"Title search failed, trying text search for: {identifier}")
+        text_results = await search_notes.fn(
+            query=identifier, search_type="text", project=project, context=context
         )
 
-    # Fallback 2: Text search as a last resort
-    logger.info(f"Title search failed, trying text search for: {identifier}")
-    text_results = await search_notes.fn(
-        query=identifier, search_type="text", project=project, context=context
-    )
-
-    # We didn't find a direct match, construct a helpful error message
-    # Handle both SearchResponse object and error strings
-    if not text_results or not hasattr(text_results, "results") or not text_results.results:
-        # No results at all
-        return format_not_found_message(active_project.name, identifier)
-    else:
-        # We found some related results
-        return format_related_results(active_project.name, identifier, text_results.results[:5])
+        # We didn't find a direct match, construct a helpful error message
+        # Handle both SearchResponse object and error strings
+        if not text_results or not hasattr(text_results, "results") or not text_results.results:
+            # No results at all
+            return format_not_found_message(active_project.name, identifier)
+        else:
+            # We found some related results
+            return format_related_results(active_project.name, identifier, text_results.results[:5])
 
 
 def format_not_found_message(project: str | None, identifier: str) -> str: