basic-memory 0.7.0__py3-none-any.whl → 0.17.4__py3-none-any.whl

basic_memory/mcp/async_client.py

@@ -1,8 +1,139 @@
-from httpx import ASGITransport, AsyncClient
+from contextlib import asynccontextmanager, AbstractAsyncContextManager
+from typing import AsyncIterator, Callable, Optional
+
+from httpx import ASGITransport, AsyncClient, Timeout
+from loguru import logger
 
 from basic_memory.api.app import app as fastapi_app
+from basic_memory.config import ConfigManager
+
+
+# Optional factory override for dependency injection
+_client_factory: Optional[Callable[[], AbstractAsyncContextManager[AsyncClient]]] = None
+
+
+def set_client_factory(factory: Callable[[], AbstractAsyncContextManager[AsyncClient]]) -> None:
+    """Override the default client factory (for cloud app, testing, etc).
+
+    Args:
+        factory: An async context manager that yields an AsyncClient
+
+    Example:
+        @asynccontextmanager
+        async def custom_client_factory():
+            async with AsyncClient(...) as client:
+                yield client
+
+        set_client_factory(custom_client_factory)
+    """
+    global _client_factory
+    _client_factory = factory
+
+
+@asynccontextmanager
+async def get_client() -> AsyncIterator[AsyncClient]:
+    """Get an AsyncClient as a context manager.
+
+    This function provides proper resource management for HTTP clients,
+    ensuring connections are closed after use. It supports three modes:
+
+    1. **Factory injection** (cloud app, tests):
+       If a custom factory is set via set_client_factory(), use that.
+
+    2. **CLI cloud mode**:
+       When cloud_mode_enabled is True, create HTTP client with auth
+       token from CLIAuth for requests to cloud proxy endpoint.
+
+    3. **Local mode** (default):
+       Use ASGI transport for in-process requests to local FastAPI app.
+
+    Usage:
+        async with get_client() as client:
+            response = await client.get("/path")
+
+    Yields:
+        AsyncClient: Configured HTTP client for the current mode
+
+    Raises:
+        RuntimeError: If cloud mode is enabled but user is not authenticated
+    """
+    if _client_factory:
+        # Use injected factory (cloud app, tests)
+        async with _client_factory() as client:
+            yield client
+    else:
+        # Default: create based on config
+        config = ConfigManager().config
+        timeout = Timeout(
+            connect=10.0,  # 10 seconds for connection
+            read=30.0,  # 30 seconds for reading response
+            write=30.0,  # 30 seconds for writing request
+            pool=30.0,  # 30 seconds for connection pool
+        )
+
+        if config.cloud_mode_enabled:
+            # CLI cloud mode: inject auth when creating client
+            from basic_memory.cli.auth import CLIAuth
+
+            auth = CLIAuth(client_id=config.cloud_client_id, authkit_domain=config.cloud_domain)
+            token = await auth.get_valid_token()
+
+            if not token:
+                raise RuntimeError(
+                    "Cloud mode enabled but not authenticated. "
+                    "Run 'basic-memory cloud login' first."
+                )
+
+            # Auth header set ONCE at client creation
+            proxy_base_url = f"{config.cloud_host}/proxy"
+            logger.info(f"Creating HTTP client for cloud proxy at: {proxy_base_url}")
+            async with AsyncClient(
+                base_url=proxy_base_url,
+                headers={"Authorization": f"Bearer {token}"},
+                timeout=timeout,
+            ) as client:
+                yield client
+        else:
+            # Local mode: ASGI transport for in-process calls
+            # Note: ASGI transport does NOT trigger FastAPI lifespan, so no special handling needed
+            logger.info("Creating ASGI client for local Basic Memory API")
+            async with AsyncClient(
+                transport=ASGITransport(app=fastapi_app), base_url="http://test", timeout=timeout
+            ) as client:
+                yield client
+
+
+def create_client() -> AsyncClient:
+    """Create an HTTP client based on configuration.
+
+    DEPRECATED: Use get_client() context manager instead for proper resource management.
+
+    This function is kept for backward compatibility but will be removed in a future version.
+    The returned client should be closed manually by calling await client.aclose().
+
+    Returns:
+        AsyncClient configured for either local ASGI or remote proxy
+    """
+    config_manager = ConfigManager()
+    config = config_manager.config
 
-BASE_URL = "memory://"
+    # Configure timeout for longer operations like write_note
+    # Default httpx timeout is 5 seconds which is too short for file operations
+    timeout = Timeout(
+        connect=10.0,  # 10 seconds for connection
+        read=30.0,  # 30 seconds for reading response
+        write=30.0,  # 30 seconds for writing request
+        pool=30.0,  # 30 seconds for connection pool
+    )
 
-# Create shared async client
-client = AsyncClient(transport=ASGITransport(app=fastapi_app), base_url=BASE_URL)
+    if config.cloud_mode_enabled:
+        # Use HTTP transport to proxy endpoint
+        proxy_base_url = f"{config.cloud_host}/proxy"
+        logger.info(f"Creating HTTP client for proxy at: {proxy_base_url}")
+        return AsyncClient(base_url=proxy_base_url, timeout=timeout)
+    else:
+        # Default: use ASGI transport for local API (development mode)
+        logger.info("Creating ASGI client for local Basic Memory API")
+        return AsyncClient(
+            transport=ASGITransport(app=fastapi_app), base_url="http://test", timeout=timeout
+        )

basic_memory/mcp/clients/__init__.py

@@ -0,0 +1,28 @@
+"""Typed internal API clients for MCP tools.
+
+These clients encapsulate API paths, error handling, and response validation.
+MCP tools become thin adapters that call these clients and format results.
+
+Usage:
+    from basic_memory.mcp.clients import KnowledgeClient, SearchClient
+
+    async with get_client() as http_client:
+        knowledge = KnowledgeClient(http_client, project_id)
+        entity = await knowledge.create_entity(entity_data)
+"""
+
+from basic_memory.mcp.clients.knowledge import KnowledgeClient
+from basic_memory.mcp.clients.search import SearchClient
+from basic_memory.mcp.clients.memory import MemoryClient
+from basic_memory.mcp.clients.directory import DirectoryClient
+from basic_memory.mcp.clients.resource import ResourceClient
+from basic_memory.mcp.clients.project import ProjectClient
+
+__all__ = [
+    "KnowledgeClient",
+    "SearchClient",
+    "MemoryClient",
+    "DirectoryClient",
+    "ResourceClient",
+    "ProjectClient",
+]

basic_memory/mcp/clients/directory.py

@@ -0,0 +1,70 @@
+"""Typed client for directory API operations.
+
+Encapsulates all /v2/projects/{project_id}/directory/* endpoints.
+"""
+
+from typing import Optional, Any
+
+from httpx import AsyncClient
+
+from basic_memory.mcp.tools.utils import call_get
+
+
+class DirectoryClient:
+    """Typed client for directory listing operations.
+
+    Centralizes:
+    - API path construction for /v2/projects/{project_id}/directory/*
+    - Response validation
+    - Consistent error handling through call_* utilities
+
+    Usage:
+        async with get_client() as http_client:
+            client = DirectoryClient(http_client, project_id)
+            nodes = await client.list("/", depth=2)
+    """
+
+    def __init__(self, http_client: AsyncClient, project_id: str):
+        """Initialize the directory client.
+
+        Args:
+            http_client: HTTPX AsyncClient for making requests
+            project_id: Project external_id (UUID) for API calls
+        """
+        self.http_client = http_client
+        self.project_id = project_id
+        self._base_path = f"/v2/projects/{project_id}/directory"
+
+    async def list(
+        self,
+        dir_name: str = "/",
+        *,
+        depth: int = 1,
+        file_name_glob: Optional[str] = None,
+    ) -> list[dict[str, Any]]:
+        """List directory contents.
+
+        Args:
+            dir_name: Directory path to list (default: root)
+            depth: How deep to traverse (default: 1)
+            file_name_glob: Optional glob pattern to filter files
+
+        Returns:
+            List of directory nodes with their contents
+
+        Raises:
+            ToolError: If the request fails
+        """
+        params: dict = {
+            "dir_name": dir_name,
+            "depth": depth,
+        }
+        if file_name_glob:
+            params["file_name_glob"] = file_name_glob
+
+        response = await call_get(
+            self.http_client,
+            f"{self._base_path}/list",
+            params=params,
+        )
+        return response.json()

basic_memory/mcp/clients/knowledge.py

@@ -0,0 +1,176 @@
+"""Typed client for knowledge/entity API operations.
+
+Encapsulates all /v2/projects/{project_id}/knowledge/* endpoints.
+"""
+
+from typing import Any
+
+from httpx import AsyncClient
+
+from basic_memory.mcp.tools.utils import call_get, call_post, call_put, call_patch, call_delete
+from basic_memory.schemas.response import EntityResponse, DeleteEntitiesResponse
+
+
+class KnowledgeClient:
+    """Typed client for knowledge graph entity operations.
+
+    Centralizes:
+    - API path construction for /v2/projects/{project_id}/knowledge/*
+    - Response validation via Pydantic models
+    - Consistent error handling through call_* utilities
+
+    Usage:
+        async with get_client() as http_client:
+            client = KnowledgeClient(http_client, project_id)
+            entity = await client.create_entity(entity_data)
+    """
+
+    def __init__(self, http_client: AsyncClient, project_id: str):
+        """Initialize the knowledge client.
+
+        Args:
+            http_client: HTTPX AsyncClient for making requests
+            project_id: Project external_id (UUID) for API calls
+        """
+        self.http_client = http_client
+        self.project_id = project_id
+        self._base_path = f"/v2/projects/{project_id}/knowledge"
+
+    # --- Entity CRUD Operations ---
+
+    async def create_entity(self, entity_data: dict[str, Any]) -> EntityResponse:
+        """Create a new entity.
+
+        Args:
+            entity_data: Entity data including title, content, folder, etc.
+
+        Returns:
+            EntityResponse with created entity details
+
+        Raises:
+            ToolError: If the request fails
+        """
+        response = await call_post(
+            self.http_client,
+            f"{self._base_path}/entities",
+            json=entity_data,
+        )
+        return EntityResponse.model_validate(response.json())
+
+    async def update_entity(self, entity_id: str, entity_data: dict[str, Any]) -> EntityResponse:
+        """Update an existing entity (full replacement).
+
+        Args:
+            entity_id: Entity external_id (UUID)
+            entity_data: Complete entity data for replacement
+
+        Returns:
+            EntityResponse with updated entity details
+
+        Raises:
+            ToolError: If the request fails
+        """
+        response = await call_put(
+            self.http_client,
+            f"{self._base_path}/entities/{entity_id}",
+            json=entity_data,
+        )
+        return EntityResponse.model_validate(response.json())
+
+    async def get_entity(self, entity_id: str) -> EntityResponse:
+        """Get an entity by ID.
+
+        Args:
+            entity_id: Entity external_id (UUID)
+
+        Returns:
+            EntityResponse with entity details
+
+        Raises:
+            ToolError: If the entity is not found or request fails
+        """
+        response = await call_get(
+            self.http_client,
+            f"{self._base_path}/entities/{entity_id}",
+        )
+        return EntityResponse.model_validate(response.json())
+
+    async def patch_entity(self, entity_id: str, patch_data: dict[str, Any]) -> EntityResponse:
+        """Partially update an entity.
+
+        Args:
+            entity_id: Entity external_id (UUID)
+            patch_data: Partial entity data to update
+
+        Returns:
+            EntityResponse with updated entity details
+
+        Raises:
+            ToolError: If the request fails
+        """
+        response = await call_patch(
+            self.http_client,
+            f"{self._base_path}/entities/{entity_id}",
+            json=patch_data,
+        )
+        return EntityResponse.model_validate(response.json())
+
+    async def delete_entity(self, entity_id: str) -> DeleteEntitiesResponse:
+        """Delete an entity.
+
+        Args:
+            entity_id: Entity external_id (UUID)
+
+        Returns:
+            DeleteEntitiesResponse confirming deletion
+
+        Raises:
+            ToolError: If the entity is not found or request fails
+        """
+        response = await call_delete(
+            self.http_client,
+            f"{self._base_path}/entities/{entity_id}",
+        )
+        return DeleteEntitiesResponse.model_validate(response.json())
+
+    async def move_entity(self, entity_id: str, destination_path: str) -> EntityResponse:
+        """Move an entity to a new location.
+
+        Args:
+            entity_id: Entity external_id (UUID)
+            destination_path: New file path for the entity
+
+        Returns:
+            EntityResponse with updated entity details
+
+        Raises:
+            ToolError: If the request fails
+        """
+        response = await call_put(
+            self.http_client,
+            f"{self._base_path}/entities/{entity_id}/move",
+            json={"destination_path": destination_path},
+        )
+        return EntityResponse.model_validate(response.json())
+
+    # --- Resolution ---
+
+    async def resolve_entity(self, identifier: str) -> str:
+        """Resolve a string identifier to an entity external_id.
+
+        Args:
+            identifier: The identifier to resolve (permalink, title, or path)
+
+        Returns:
+            The resolved entity external_id (UUID)
+
+        Raises:
+            ToolError: If the identifier cannot be resolved
+        """
+        response = await call_post(
+            self.http_client,
+            f"{self._base_path}/resolve",
+            json={"identifier": identifier},
+        )
+        data = response.json()
+        return data["external_id"]

basic_memory/mcp/clients/memory.py

@@ -0,0 +1,120 @@
+"""Typed client for memory/context API operations.
+
+Encapsulates all /v2/projects/{project_id}/memory/* endpoints.
+"""
+
+from typing import Optional
+
+from httpx import AsyncClient
+
+from basic_memory.mcp.tools.utils import call_get
+from basic_memory.schemas.memory import GraphContext
+
+
+class MemoryClient:
+    """Typed client for memory context operations.
+
+    Centralizes:
+    - API path construction for /v2/projects/{project_id}/memory/*
+    - Response validation via Pydantic models
+    - Consistent error handling through call_* utilities
+
+    Usage:
+        async with get_client() as http_client:
+            client = MemoryClient(http_client, project_id)
+            context = await client.build_context("memory://specs/search")
+    """
+
+    def __init__(self, http_client: AsyncClient, project_id: str):
+        """Initialize the memory client.
+
+        Args:
+            http_client: HTTPX AsyncClient for making requests
+            project_id: Project external_id (UUID) for API calls
+        """
+        self.http_client = http_client
+        self.project_id = project_id
+        self._base_path = f"/v2/projects/{project_id}/memory"
+
+    async def build_context(
+        self,
+        path: str,
+        *,
+        depth: int = 1,
+        timeframe: Optional[str] = None,
+        page: int = 1,
+        page_size: int = 10,
+        max_related: int = 10,
+    ) -> GraphContext:
+        """Build context from a memory path.
+
+        Args:
+            path: The path to build context for (without memory:// prefix)
+            depth: How deep to traverse relations
+            timeframe: Time filter (e.g., "7d", "1 week")
+            page: Page number (1-indexed)
+            page_size: Results per page
+            max_related: Maximum related items per result
+
+        Returns:
+            GraphContext with hierarchical results
+
+        Raises:
+            ToolError: If the request fails
+        """
+        params: dict = {
+            "depth": depth,
+            "page": page,
+            "page_size": page_size,
+            "max_related": max_related,
+        }
+        if timeframe:
+            params["timeframe"] = timeframe
+
+        response = await call_get(
+            self.http_client,
+            f"{self._base_path}/{path}",
+            params=params,
+        )
+        return GraphContext.model_validate(response.json())
+
+    async def recent(
+        self,
+        *,
+        timeframe: str = "7d",
+        depth: int = 1,
+        types: Optional[list[str]] = None,
+        page: int = 1,
+        page_size: int = 10,
+    ) -> GraphContext:
+        """Get recent activity.
+
+        Args:
+            timeframe: Time filter (e.g., "7d", "1 week", "2 days ago")
+            depth: How deep to traverse relations
+            types: Filter by item types
+            page: Page number (1-indexed)
+            page_size: Results per page
+
+        Returns:
+            GraphContext with recent activity
+
+        Raises:
+            ToolError: If the request fails
+        """
+        params: dict = {
+            "timeframe": timeframe,
+            "depth": depth,
+            "page": page,
+            "page_size": page_size,
+        }
+        if types:
+            # Join types as comma-separated string if provided
+            params["type"] = ",".join(types) if isinstance(types, list) else types
+
+        response = await call_get(
+            self.http_client,
+            f"{self._base_path}/recent",
+            params=params,
+        )
+        return GraphContext.model_validate(response.json())

basic_memory/mcp/clients/project.py

@@ -0,0 +1,89 @@
+"""Typed client for project API operations.
+
+Encapsulates project-level endpoints.
+"""
+
+from typing import Any
+
+from httpx import AsyncClient
+
+from basic_memory.mcp.tools.utils import call_get, call_post, call_delete
+from basic_memory.schemas.project_info import ProjectList, ProjectStatusResponse
+
+
+class ProjectClient:
+    """Typed client for project management operations.
+
+    Centralizes:
+    - API path construction for project endpoints
+    - Response validation via Pydantic models
+    - Consistent error handling through call_* utilities
+
+    Note: This client does not require a project_id since it operates
+    across projects.
+
+    Usage:
+        async with get_client() as http_client:
+            client = ProjectClient(http_client)
+            projects = await client.list_projects()
+    """
+
+    def __init__(self, http_client: AsyncClient):
+        """Initialize the project client.
+
+        Args:
+            http_client: HTTPX AsyncClient for making requests
+        """
+        self.http_client = http_client
+
+    async def list_projects(self) -> ProjectList:
+        """List all available projects.
+
+        Returns:
+            ProjectList with all projects and default project name
+
+        Raises:
+            ToolError: If the request fails
+        """
+        response = await call_get(
+            self.http_client,
+            "/projects/projects",
+        )
+        return ProjectList.model_validate(response.json())
+
+    async def create_project(self, project_data: dict[str, Any]) -> ProjectStatusResponse:
+        """Create a new project.
+
+        Args:
+            project_data: Project creation data (name, path, set_default)
+
+        Returns:
+            ProjectStatusResponse with creation result
+
+        Raises:
+            ToolError: If the request fails
+        """
+        response = await call_post(
+            self.http_client,
+            "/projects/projects",
+            json=project_data,
+        )
+        return ProjectStatusResponse.model_validate(response.json())
+
+    async def delete_project(self, project_external_id: str) -> ProjectStatusResponse:
+        """Delete a project by its external ID.
+
+        Args:
+            project_external_id: Project external ID (UUID)
+
+        Returns:
+            ProjectStatusResponse with deletion result
+
+        Raises:
+            ToolError: If the request fails
+        """
+        response = await call_delete(
+            self.http_client,
+            f"/v2/projects/{project_external_id}",
+        )
+        return ProjectStatusResponse.model_validate(response.json())

basic_memory/mcp/clients/resource.py

@@ -0,0 +1,71 @@
+"""Typed client for resource API operations.
+
+Encapsulates all /v2/projects/{project_id}/resource/* endpoints.
+"""
+
+from typing import Optional
+
+from httpx import AsyncClient, Response
+
+from basic_memory.mcp.tools.utils import call_get
+
+
+class ResourceClient:
+    """Typed client for resource operations.
+
+    Centralizes:
+    - API path construction for /v2/projects/{project_id}/resource/*
+    - Consistent error handling through call_* utilities
+
+    Note: This client returns raw Response objects for resources since they
+    may be text, images, or other binary content that needs special handling.
+
+    Usage:
+        async with get_client() as http_client:
+            client = ResourceClient(http_client, project_id)
+            response = await client.read(entity_id)
+            text = response.text
+    """
+
+    def __init__(self, http_client: AsyncClient, project_id: str):
+        """Initialize the resource client.
+
+        Args:
+            http_client: HTTPX AsyncClient for making requests
+            project_id: Project external_id (UUID) for API calls
+        """
+        self.http_client = http_client
+        self.project_id = project_id
+        self._base_path = f"/v2/projects/{project_id}/resource"
+
+    async def read(
+        self,
+        entity_id: str,
+        *,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Response:
+        """Read a resource by entity ID.
+
+        Args:
+            entity_id: Entity external_id (UUID)
+            page: Optional page number for paginated content
+            page_size: Optional page size for paginated content
+
+        Returns:
+            Raw HTTP Response (caller handles text/binary content)
+
+        Raises:
+            ToolError: If the resource is not found or request fails
+        """
+        params: dict = {}
+        if page is not None:
+            params["page"] = page
+        if page_size is not None:
+            params["page_size"] = page_size
+
+        return await call_get(
+            self.http_client,
+            f"{self._base_path}/{entity_id}",
+            params=params if params else None,
+        )