feat: Merge Cloud auth (#291)

Signed-off-by: phernandez <paul@basicmachines.co>
Signed-off-by: Joe P <joe@basicmemory.com>
Co-authored-by: phernandez <paul@basicmachines.co>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

pyproject.toml

@@ -30,7 +30,7 @@ dependencies = [
     "alembic>=1.14.1",
     "pillow>=11.1.0",
     "pybars3>=0.9.7",
-    "fastmcp==2.10.2",
+    "fastmcp>=2.10.2",
     "pyjwt>=2.10.1",
     "python-dotenv>=1.1.0",
     "pytest-aio>=1.9.0",

src/basic_memory/api/routers/project_router.py

@@ -14,6 +14,7 @@
 )
 
 # Router for resources in a specific project
+# The ProjectPathDep is used in the path as a prefix, so the request path is like /{project}/project/info
 project_router = APIRouter(prefix="/project", tags=["project"])
 
 # Router for managing project resources
@@ -29,6 +30,25 @@ async def get_project_info(
     return await project_service.get_project_info(project)
 
 
+@project_router.get("/item", response_model=ProjectItem)
+async def get_project(
+    project_service: ProjectServiceDep,
+    project: ProjectPathDep,
+) -> ProjectItem:
+    """Get bassic info about the specified Basic Memory project."""
+    found_project = await project_service.get_project(project)
+    if not found_project:
+        raise HTTPException(
+            status_code=404, detail=f"Project: '{project}' does not exist"
+        )  # pragma: no cover
+
+    return ProjectItem(
+        name=found_project.name,
+        path=found_project.path,
+        is_default=found_project.is_default or False,
+    )
+
+
 # Update a project
 @project_router.patch("/{name}", response_model=ProjectStatusResponse)
 async def update_project(
@@ -217,6 +237,27 @@ async def set_default_project(
         raise HTTPException(status_code=400, detail=str(e))
 
 
+# Get the default project
+@project_resource_router.get("/default", response_model=ProjectItem)
+async def get_default_project(
+    project_service: ProjectServiceDep,
+) -> ProjectItem:
+    """Get the default project.
+
+    Returns:
+        Response with project default information
+    """
+    # Get the old default project
+    default_name = project_service.default_project
+    default_project = await project_service.get_project(default_name)
+    if not default_project:  # pragma: no cover
+        raise HTTPException(  # pragma: no cover
+            status_code=404, detail=f"Default Project: '{default_name}' does not exist"
+        )
+
+    return ProjectItem(name=default_project.name, path=default_project.path, is_default=True)
+
+
 # Synchronize projects between config and database
 @project_resource_router.post("/sync", response_model=ProjectStatusResponse)
 async def synchronize_projects(

src/basic_memory/cli/app.py

@@ -3,7 +3,6 @@
 import typer
 
 from basic_memory.config import get_project_config, ConfigManager
-from basic_memory.mcp.project_session import session
 
 
 def version_callback(value: bool) -> None:
@@ -28,7 +27,7 @@ def app_callback(
         None,
         "--project",
         "-p",
-        help="Specify which project to use 1",
+        help="Specify which project to use",
         envvar="BASIC_MEMORY_PROJECT",
     ),
     version: Optional[bool] = typer.Option(
@@ -51,18 +50,11 @@ def app_callback(
 
         # Initialize MCP session with the specified project or default
         if project:  # pragma: no cover
-            # Use the project specified via --project flag
-            current_project_config = get_project_config(project)
-            session.set_current_project(current_project_config.name)
-
             # Update the global config to use this project
             from basic_memory.config import update_current_project
 
+            # TODO set active project via cli
             update_current_project(project)
-        else:
-            # Use the default project
-            current_project = app_config.default_project
-            session.set_current_project(current_project)
 
 
 # Register sub-command groups

src/basic_memory/cli/commands/mcp.py

@@ -5,6 +5,7 @@
 
 from basic_memory.cli.app import app
 from basic_memory.config import ConfigManager
+from basic_memory.mcp.middleware import ProjectContextMiddleware
 
 # Import mcp instance
 from basic_memory.mcp.server import mcp as mcp_server  # pragma: no cover
@@ -63,6 +64,9 @@ def run_file_sync():
     # Now run the MCP server (blocks)
     logger.info(f"Starting MCP server with {transport.upper()} transport")
 
+    # middleware to store the active project
+    mcp_server.add_middleware(ProjectContextMiddleware())
+
     if transport == "stdio":
         mcp_server.run(
             transport=transport,

src/basic_memory/cli/commands/project.py

@@ -9,7 +9,6 @@
 from rich.table import Table
 
 from basic_memory.cli.app import app
-from basic_memory.mcp.project_session import session
 from basic_memory.mcp.resources.project_info import project_info
 import json
 from datetime import datetime
@@ -52,13 +51,11 @@ def list_projects() -> None:
         table = Table(title="Basic Memory Projects")
         table.add_column("Name", style="cyan")
         table.add_column("Path", style="green")
-        table.add_column("Default", style="yellow")
-        table.add_column("Active", style="magenta")
+        table.add_column("Default", style="magenta")
 
         for project in result.projects:
             is_default = "✓" if project.is_default else ""
-            is_active = "✓" if session.get_current_project() == project.name else ""
-            table.add_row(project.name, format_path(project.path), is_default, is_active)
+            table.add_row(project.name, format_path(project.path), is_default)
 
         console.print(table)
     except Exception as e:
@@ -161,9 +158,10 @@ def move_project(
         data = {"path": resolved_path}
 
         project_permalink = generate_permalink(name)
-        current_project = session.get_current_project()
+
+        # TODO fix route to use ProjectPathDep
         response = asyncio.run(
-            call_patch(client, f"/{current_project}/project/{project_permalink}", json=data)
+            call_patch(client, f"/{name}/project/{project_permalink}", json=data)
         )
         result = ProjectStatusResponse.model_validate(response.json())
 

src/basic_memory/mcp/async_client.py

@@ -1,25 +1,25 @@
+import os
 from httpx import ASGITransport, AsyncClient
 from loguru import logger
 
 from basic_memory.api.app import app as fastapi_app
-from basic_memory.config import ConfigManager
 
 
 def create_client() -> AsyncClient:
     """Create an HTTP client based on configuration.
 
     Returns:
-        AsyncClient configured for either local ASGI or remote HTTP transport
+        AsyncClient configured for either local ASGI or remote proxy
     """
-    config_manager = ConfigManager()
-    config = config_manager.load_config()
+    proxy_base_url = os.getenv("BASIC_MEMORY_PROXY_URL", None)
+    logger.info(f"BASIC_MEMORY_PROXY_URL: {proxy_base_url}")
 
-    if config.api_url:
-        # Use HTTP transport for remote API
-        logger.info(f"Creating HTTP client for remote Basic Memory API: {config.api_url}")
-        return AsyncClient(base_url=config.api_url)
+    if proxy_base_url:
+        # Use HTTP transport to proxy endpoint
+        logger.info(f"Creating HTTP client for proxy at: {proxy_base_url}")
+        return AsyncClient(base_url=proxy_base_url)
     else:
-        # Use ASGI transport for local API
+        # Default: use ASGI transport for local API (development mode)
         logger.debug("Creating ASGI client for local Basic Memory API")
         return AsyncClient(transport=ASGITransport(app=fastapi_app), base_url="http://test")
 

src/basic_memory/mcp/middleware.py

@@ -0,0 +1,52 @@
+from typing import Any
+from loguru import logger
+from fastmcp.server.middleware import Middleware, MiddlewareContext
+
+from basic_memory.config import ConfigManager
+from basic_memory.schemas.project_info import ProjectItem
+
+
+class ProjectContextMiddleware(Middleware):
+    def __init__(self):
+        config = ConfigManager().config
+        default_project_name = config.default_project
+        default_project_path = config.projects[default_project_name]
+
+        self.default_project = ProjectItem(
+            name=default_project_name, path=default_project_path, is_default=True
+        )
+        self.sessions: dict[str, ProjectItem] = {}
+
+    async def on_call_tool(self, context: MiddlewareContext, call_next) -> Any:
+        # Initialize context with default project if not set
+        if context.fastmcp_context:
+            session_id = context.fastmcp_context.session_id
+            project = self.sessions.get(session_id)
+
+            active_project = project or self.default_project
+
+            # store in sessions
+            if not project:
+                self.sessions[session_id] = active_project
+
+            # set active project on context
+            context.fastmcp_context.set_state("active_project", active_project)
+            logger.debug(
+                f"project context set: session_id={session_id}, active_project={active_project}"
+            )
+
+        # call tool
+        result = await call_next(context)
+
+        # set global state for if the project changed during tool call
+        if context.fastmcp_context:
+            session_id = context.fastmcp_context.session_id
+            active_project = context.fastmcp_context.get_state("active_project")
+            project = self.sessions.get(session_id)
+            if project != active_project:
+                logger.debug(
+                    f"project session saved: session_id={session_id}, active_project={active_project}"
+                )
+                self.sessions[session_id] = active_project
+
+        return result

src/basic_memory/mcp/project_context.py

@@ -0,0 +1,99 @@
+"""Project session management for Basic Memory MCP server.
+
+Provides simple in-memory project context for MCP tools, allowing users to switch
+between projects during a conversation without restarting the server.
+
+Session Persistence Flow:
+  1. Pre-tool: Middleware loads self.sessions[session_id] → sets context state
+  2. Tool execution: Uses context.get_state("active_project")
+  3. Project switching: Tool calls set_active_project() → updates context state
+  4. Post-tool: Middleware detects context change → saves to self.sessions[session_id]
+"""
+
+from typing import Optional
+from httpx import AsyncClient
+from loguru import logger
+
+from fastmcp import Context
+
+from basic_memory.mcp.tools.utils import call_get
+from basic_memory.schemas.project_info import ProjectItem
+from basic_memory.utils import generate_permalink
+
+
+async def set_active_project(
+    client: AsyncClient, *, context: Context | None, project: ProjectItem
+) -> None:
+    """Set the active project context.
+
+    Args:
+        client (AsyncClient): The client to use for making requests to fastapi.
+        project_name: The project to switch to
+        context: Optional FastMCP context containing project session state
+    """
+    active_project = await get_active_project(client, context=context)
+    if active_project.name != project.name:
+        previous_project = active_project
+        # set project in the context
+        if context:
+            context.set_state("active_project", project)
+            await context.info(
+                f"Context {context.session_id} Switched active project: {previous_project} -> {project.name}"
+            )
+            logger.info(f"Switched active project: {previous_project} -> {project.name}")
+    else:
+        logger.debug(f"No change for active project: {active_project}")
+
+
+async def get_active_project(
+    client: AsyncClient, *, context: Context | None, project_override: Optional[str] = None
+) -> ProjectItem:
+    """
+    Get the active project for a tool call.
+    If no context is provided, the active project is returned from the default project
+
+    Args:
+        client (AsyncClient): The client to use for making requests to fastapi.
+        project_override: Optional explicit project name from tool parameter
+        context: Optional FastMCP context containing project session state
+
+    Returns:
+        The project to use for the tool call
+    """
+
+    # Try to get active project from context first
+    if context:
+        active_project = context.get_state("active_project")
+        logger.debug(f"Context {context.session_id} found active project: {active_project}")
+    else:
+        response = await call_get(
+            client,
+            "/projects/default",
+        )
+        active_project = ProjectItem.model_validate(response.json())
+        logger.debug(f"No context provided. Using default project: {active_project}")
+
+    # Handle project override
+    if project_override:
+        logger.debug(f"overriding active project: {project_override}")
+        permalink = generate_permalink(project_override)
+        response = await call_get(
+            client,
+            f"/{permalink}/project/item",
+        )
+        active_project = ProjectItem.model_validate(response.json())
+
+    return active_project
+
+
+def add_project_metadata(result: str, project_name: str) -> str:
+    """Add project context as metadata footer for LLM awareness.
+
+    Args:
+        result: The tool result string
+        project_name: The project name that was used
+
+    Returns:
+        Result with project metadata footer
+    """
+    return f"{result}\n\n<!-- Project: {project_name} -->"  # pragma: no cover