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

basic_memory/mcp/resources/project_info.py

@@ -5,7 +5,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.utils import call_get
@@ -59,11 +59,13 @@ async def project_info(
         print(f"Basic Memory version: {info.system.version}")
     """
     logger.info("Getting project info")
-    project_config = await get_active_project(client, project, context)
-    project_url = project_config.permalink
 
-    # Call the API endpoint
-    response = await call_get(client, f"{project_url}/project/info")
+    async with get_client() as client:
+        project_config = await get_active_project(client, project, context)
+        project_url = project_config.permalink
 
-    # Convert response to ProjectInfoResponse
-    return ProjectInfoResponse.model_validate(response.json())
+        # Call the API endpoint
+        response = await call_get(client, f"{project_url}/project/info")
+
+        # Convert response to ProjectInfoResponse
+        return ProjectInfoResponse.model_validate(response.json())

basic_memory/mcp/tools/build_context.py

@@ -5,7 +5,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.utils import call_get
@@ -102,42 +102,43 @@ async def build_context(
 
     # URL is already validated and normalized by MemoryUrl type annotation
 
-    # Get the active project using the new stateless approach
-    active_project = await get_active_project(client, project, context)
-
-    # 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 a proper GraphContext with status message
-        from basic_memory.schemas.memory import MemoryMetadata
-        from datetime import datetime
-
-        return GraphContext(
-            results=[],
-            metadata=MemoryMetadata(
-                depth=depth or 1,
-                timeframe=timeframe,
-                generated_at=datetime.now().astimezone(),
-                primary_count=0,
-                related_count=0,
-                uri=migration_status,  # Include status in metadata
-            ),
+    async with get_client() as client:
+        # Get the active project using the new stateless approach
+        active_project = await get_active_project(client, project, context)
+
+        # 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 a proper GraphContext with status message
+            from basic_memory.schemas.memory import MemoryMetadata
+            from datetime import datetime
+
+            return GraphContext(
+                results=[],
+                metadata=MemoryMetadata(
+                    depth=depth or 1,
+                    timeframe=timeframe,
+                    generated_at=datetime.now().astimezone(),
+                    primary_count=0,
+                    related_count=0,
+                    uri=migration_status,  # Include status in metadata
+                ),
+            )
+        project_url = active_project.project_url
+
+        response = await call_get(
+            client,
+            f"{project_url}/memory/{memory_url_path(url)}",
+            params={
+                "depth": depth,
+                "timeframe": timeframe,
+                "page": page,
+                "page_size": page_size,
+                "max_related": max_related,
+            },
         )
-    project_url = active_project.project_url
-
-    response = await call_get(
-        client,
-        f"{project_url}/memory/{memory_url_path(url)}",
-        params={
-            "depth": depth,
-            "timeframe": timeframe,
-            "page": page,
-            "page_size": page_size,
-            "max_related": max_related,
-        },
-    )
-    return GraphContext.model_validate(response.json())
+        return GraphContext.model_validate(response.json())

basic_memory/mcp/tools/canvas.py

@@ -9,7 +9,7 @@ from typing import Dict, List, Any, 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.utils import call_put
@@ -94,29 +94,30 @@ async def canvas(
     Raises:
         ToolError: If project doesn't exist or folder path is invalid
     """
-    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
 
-    # Ensure path has .canvas extension
-    file_title = title if title.endswith(".canvas") else f"{title}.canvas"
-    file_path = f"{folder}/{file_title}"
+        # Ensure path has .canvas extension
+        file_title = title if title.endswith(".canvas") else f"{title}.canvas"
+        file_path = f"{folder}/{file_title}"
 
-    # Create canvas data structure
-    canvas_data = {"nodes": nodes, "edges": edges}
+        # Create canvas data structure
+        canvas_data = {"nodes": nodes, "edges": edges}
 
-    # Convert to JSON
-    canvas_json = json.dumps(canvas_data, indent=2)
+        # Convert to JSON
+        canvas_json = json.dumps(canvas_data, indent=2)
 
-    # Write the file using the resource API
-    logger.info(f"Creating canvas file: {file_path} in project {project}")
-    response = await call_put(client, f"{project_url}/resource/{file_path}", json=canvas_json)
+        # Write the file using the resource API
+        logger.info(f"Creating canvas file: {file_path} in project {project}")
+        response = await call_put(client, f"{project_url}/resource/{file_path}", json=canvas_json)
 
-    # Parse response
-    result = response.json()
-    logger.debug(result)
+        # Parse response
+        result = response.json()
+        logger.debug(result)
 
-    # Build summary
-    action = "Created" if response.status_code == 201 else "Updated"
-    summary = [f"# {action}: {file_path}", "\nThe canvas is ready to open in Obsidian."]
+        # Build summary
+        action = "Created" if response.status_code == 201 else "Updated"
+        summary = [f"# {action}: {file_path}", "\nThe canvas is ready to open in Obsidian."]
 
-    return "\n".join(summary)
+        return "\n".join(summary)

basic_memory/mcp/tools/chatgpt_tools.py

@@ -14,6 +14,7 @@ from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.search import search_notes
 from basic_memory.mcp.tools.read_note import read_note
 from basic_memory.schemas.search import SearchResponse
+from basic_memory.config import ConfigManager
 
 
 def _format_search_results_for_chatgpt(results: SearchResponse) -> List[Dict[str, Any]]:
@@ -90,10 +91,14 @@ async def search(
     logger.info(f"ChatGPT search request: query='{query}'")
 
     try:
+        # ChatGPT tools don't expose project parameter, so use default project
+        config = ConfigManager().config
+        default_project = config.default_project
+
         # Call underlying search_notes with sensible defaults for ChatGPT
         results = await search_notes.fn(
             query=query,
-            project=None,  # Let project resolution happen automatically
+            project=default_project,  # Use default project for ChatGPT
             page=1,
             page_size=10,  # Reasonable default for ChatGPT consumption
             search_type="text",  # Default to full-text search
@@ -149,10 +154,14 @@ async def fetch(
     logger.info(f"ChatGPT fetch request: id='{id}'")
 
     try:
+        # ChatGPT tools don't expose project parameter, so use default project
+        config = ConfigManager().config
+        default_project = config.default_project
+
         # Call underlying read_note function
         content = await read_note.fn(
             identifier=id,
-            project=None,  # Let project resolution happen automatically
+            project=default_project,  # Use default project for ChatGPT
             page=1,
             page_size=10,  # Default pagination
             context=context,

basic_memory/mcp/tools/delete_note.py

@@ -7,7 +7,7 @@ from fastmcp import Context
 from basic_memory.mcp.project_context import get_active_project
 from basic_memory.mcp.tools.utils import call_delete
 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.schemas import DeleteEntitiesResponse
 
 
@@ -202,23 +202,24 @@ async def delete_note(
         with suggestions for finding the correct identifier, including search
         commands and alternative formats to try.
     """
-    active_project = await get_active_project(client, project, context)
-    project_url = active_project.project_url
-
-    try:
-        response = await call_delete(client, f"{project_url}/knowledge/entities/{identifier}")
-        result = DeleteEntitiesResponse.model_validate(response.json())
-
-        if result.deleted:
-            logger.info(
-                f"Successfully deleted note: {identifier} in project: {active_project.name}"
-            )
-            return True
-        else:
-            logger.warning(f"Delete operation completed but note was not deleted: {identifier}")
-            return False
-
-    except Exception as e:  # pragma: no cover
-        logger.error(f"Delete failed for '{identifier}': {e}, project: {active_project.name}")
-        # Return formatted error message for better user experience
-        return _format_delete_error_response(active_project.name, str(e), identifier)
+    async with get_client() as client:
+        active_project = await get_active_project(client, project, context)
+        project_url = active_project.project_url
+
+        try:
+            response = await call_delete(client, f"{project_url}/knowledge/entities/{identifier}")
+            result = DeleteEntitiesResponse.model_validate(response.json())
+
+            if result.deleted:
+                logger.info(
+                    f"Successfully deleted note: {identifier} in project: {active_project.name}"
+                )
+                return True
+            else:
+                logger.warning(f"Delete operation completed but note was not deleted: {identifier}")
+                return False
+
+        except Exception as e:  # pragma: no cover
+            logger.error(f"Delete failed for '{identifier}': {e}, project: {active_project.name}")
+            # Return formatted error message for better user experience
+            return _format_delete_error_response(active_project.name, str(e), identifier)

basic_memory/mcp/tools/edit_note.py

@@ -5,7 +5,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, add_project_metadata
 from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.utils import call_patch
@@ -214,106 +214,107 @@ async def edit_note(
         search_notes() first to find the correct identifier. The tool provides detailed
         error messages with suggestions if operations fail.
     """
-    active_project = await get_active_project(client, project, context)
-    project_url = active_project.project_url
-
-    logger.info("MCP tool call", tool="edit_note", identifier=identifier, operation=operation)
-
-    # Validate operation
-    valid_operations = ["append", "prepend", "find_replace", "replace_section"]
-    if operation not in valid_operations:
-        raise ValueError(
-            f"Invalid operation '{operation}'. Must be one of: {', '.join(valid_operations)}"
-        )
-
-    # Validate required parameters for specific operations
-    if operation == "find_replace" and not find_text:
-        raise ValueError("find_text parameter is required for find_replace operation")
-    if operation == "replace_section" and not section:
-        raise ValueError("section parameter is required for replace_section operation")
-
-    # Use the PATCH endpoint to edit the entity
-    try:
-        # Prepare the edit request data
-        edit_data = {
-            "operation": operation,
-            "content": content,
-        }
-
-        # Add optional parameters
-        if section:
-            edit_data["section"] = section
-        if find_text:
-            edit_data["find_text"] = find_text
-        if expected_replacements != 1:  # Only send if different from default
-            edit_data["expected_replacements"] = str(expected_replacements)
-
-        # Call the PATCH endpoint
-        url = f"{project_url}/knowledge/entities/{identifier}"
-        response = await call_patch(client, url, json=edit_data)
-        result = EntityResponse.model_validate(response.json())
-
-        # Format summary
-        summary = [
-            f"# Edited note ({operation})",
-            f"project: {active_project.name}",
-            f"file_path: {result.file_path}",
-            f"permalink: {result.permalink}",
-            f"checksum: {result.checksum[:8] if result.checksum else 'unknown'}",
-        ]
-
-        # Add operation-specific details
-        if operation == "append":
-            lines_added = len(content.split("\n"))
-            summary.append(f"operation: Added {lines_added} lines to end of note")
-        elif operation == "prepend":
-            lines_added = len(content.split("\n"))
-            summary.append(f"operation: Added {lines_added} lines to beginning of note")
-        elif operation == "find_replace":
-            # For find_replace, we can't easily count replacements from here
-            # since we don't have the original content, but the server handled it
-            summary.append("operation: Find and replace operation completed")
-        elif operation == "replace_section":
-            summary.append(f"operation: Replaced content under section '{section}'")
-
-        # Count observations by category (reuse logic from write_note)
-        categories = {}
-        if result.observations:
-            for obs in result.observations:
-                categories[obs.category] = categories.get(obs.category, 0) + 1
-
-            summary.append("\\n## Observations")
-            for category, count in sorted(categories.items()):
-                summary.append(f"- {category}: {count}")
-
-        # Count resolved/unresolved relations
-        unresolved = 0
-        resolved = 0
-        if result.relations:
-            unresolved = sum(1 for r in result.relations if not r.to_id)
-            resolved = len(result.relations) - unresolved
-
-            summary.append("\\n## Relations")
-            summary.append(f"- Resolved: {resolved}")
-            if unresolved:
-                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),
-            status_code=response.status_code,
-        )
-
-        result = "\n".join(summary)
-        return add_project_metadata(result, active_project.name)
-
-    except Exception as e:
-        logger.error(f"Error editing note: {e}")
-        return _format_error_response(
-            str(e), operation, identifier, find_text, expected_replacements, active_project.name
-        )
+    async with get_client() as client:
+        active_project = await get_active_project(client, project, context)
+        project_url = active_project.project_url
+
+        logger.info("MCP tool call", tool="edit_note", identifier=identifier, operation=operation)
+
+        # Validate operation
+        valid_operations = ["append", "prepend", "find_replace", "replace_section"]
+        if operation not in valid_operations:
+            raise ValueError(
+                f"Invalid operation '{operation}'. Must be one of: {', '.join(valid_operations)}"
+            )
+
+        # Validate required parameters for specific operations
+        if operation == "find_replace" and not find_text:
+            raise ValueError("find_text parameter is required for find_replace operation")
+        if operation == "replace_section" and not section:
+            raise ValueError("section parameter is required for replace_section operation")
+
+        # Use the PATCH endpoint to edit the entity
+        try:
+            # Prepare the edit request data
+            edit_data = {
+                "operation": operation,
+                "content": content,
+            }
+
+            # Add optional parameters
+            if section:
+                edit_data["section"] = section
+            if find_text:
+                edit_data["find_text"] = find_text
+            if expected_replacements != 1:  # Only send if different from default
+                edit_data["expected_replacements"] = str(expected_replacements)
+
+            # Call the PATCH endpoint
+            url = f"{project_url}/knowledge/entities/{identifier}"
+            response = await call_patch(client, url, json=edit_data)
+            result = EntityResponse.model_validate(response.json())
+
+            # Format summary
+            summary = [
+                f"# Edited note ({operation})",
+                f"project: {active_project.name}",
+                f"file_path: {result.file_path}",
+                f"permalink: {result.permalink}",
+                f"checksum: {result.checksum[:8] if result.checksum else 'unknown'}",
+            ]
+
+            # Add operation-specific details
+            if operation == "append":
+                lines_added = len(content.split("\n"))
+                summary.append(f"operation: Added {lines_added} lines to end of note")
+            elif operation == "prepend":
+                lines_added = len(content.split("\n"))
+                summary.append(f"operation: Added {lines_added} lines to beginning of note")
+            elif operation == "find_replace":
+                # For find_replace, we can't easily count replacements from here
+                # since we don't have the original content, but the server handled it
+                summary.append("operation: Find and replace operation completed")
+            elif operation == "replace_section":
+                summary.append(f"operation: Replaced content under section '{section}'")
+
+            # Count observations by category (reuse logic from write_note)
+            categories = {}
+            if result.observations:
+                for obs in result.observations:
+                    categories[obs.category] = categories.get(obs.category, 0) + 1
+
+                summary.append("\\n## Observations")
+                for category, count in sorted(categories.items()):
+                    summary.append(f"- {category}: {count}")
+
+            # Count resolved/unresolved relations
+            unresolved = 0
+            resolved = 0
+            if result.relations:
+                unresolved = sum(1 for r in result.relations if not r.to_id)
+                resolved = len(result.relations) - unresolved
+
+                summary.append("\\n## Relations")
+                summary.append(f"- Resolved: {resolved}")
+                if unresolved:
+                    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),
+                status_code=response.status_code,
+            )
+
+            result = "\n".join(summary)
+            return add_project_metadata(result, active_project.name)
+
+        except Exception as e:
+            logger.error(f"Error editing note: {e}")
+            return _format_error_response(
+                str(e), operation, identifier, find_text, expected_replacements, active_project.name
+            )