Claude Code Analysis

Based on my analysis, I can provide a thorough explanation of issue #53 and a potential solution.

Issue Analysis

The basic-memory project has two methods for keeping the knowledge database in sync with files:

basic-memory sync --watch - A CLI command that synchronizes files and then continuously watches for changes
basic-memory mcp - The MCP server command that allows integration with LLMs (like Claude)

Currently, users need to run both commands in separate terminal windows if they want real-time file synchronization while using the MCP server.

Root Cause

The MCP server command (basic-memory mcp) doesn't have a --watch flag like the sync command does. When the MCP server runs, it doesn't automatically start the watch service to monitor file changes, requiring users to run a separate sync process.

Proposed Solution

Add a --watch flag to the MCP command that starts the watch service alongside the MCP server, similar to how the sync command works.

Files to Modify

src/basic_memory/cli/commands/mcp.py:
- Add a --watch option parameter to the mcp() function
- Modify the function to start the watch service when the flag is enabled

Implementation Details

Add the watch flag and functionality to the MCP command:

@app.command()
def mcp(
    watch: bool = typer.Option(
        False,
        "--watch",
        "-w",
        help="Start watching for file changes after starting the MCP server.",
    ),
):  # pragma: no cover
    """Run the MCP server for Claude Desktop integration."""
    import asyncio
    import threading
    from basic_memory.sync.sync_service import SyncService
    from basic_memory.sync.watch_service import WatchService
    from basic_memory.cli.commands.sync import get_sync_service

    home_dir = config.home
    project_name = config.project

    logger.info(f"Starting Basic Memory MCP server {basic_memory.__version__}")
    logger.info(f"Project: {project_name}")
    logger.info(f"Project directory: {home_dir}")

    # Start watch service in a separate thread if requested
    if watch:
        logger.info("Starting watch service alongside MCP server")
        
        # Define the watch service running function
        def run_watch_service():
            async def start_watch():
                sync_service = await get_sync_service()
                watch_service = WatchService(
                    sync_service=sync_service,
                    file_service=sync_service.entity_service.file_service,
                    config=config,
                )
                # Initial sync without progress bars
                await sync_service.sync(config.home, show_progress=False)
                # Watch for changes
                await watch_service.run()
            
            # Run the async function in the event loop
            asyncio.run(start_watch())
        
        # Start watch service in a background thread
        watch_thread = threading.Thread(target=run_watch_service, daemon=True)
        watch_thread.start()
        
    # Run the MCP server (this will block the main thread)
    mcp_server.run()

Add tests for the new functionality:
- Create a test file in tests/cli/test_mcp.py to verify the watch flag is properly handled

Design Considerations

Threading Approach: Running the watch service in a separate daemon thread allows it to work alongside the MCP server without blocking it.
Reuse of Existing Code: The implementation reuses the existing get_sync_service() function and WatchService class to maintain consistency with the sync command.
Error Handling: Both the MCP server and the watch service have their own error handling. If the watch service fails, the MCP server will continue to run.
Daemon Thread: Using a daemon thread ensures that when the main MCP server stops, the watch thread is automatically terminated.

Testing Strategy

Test that the MCP server starts properly with the --watch flag.
Verify file changes are detected and synced while the MCP server is running.
Ensure proper cleanup when the MCP server is stopped.

This implementation would allow users to run just a single command (basic-memory mcp --watch) instead of needing to run both the MCP server and sync watch processes separately.

🤖 Generated with Claude Code GitHub Action

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

watch files from mcp process #53

Description

Feature Description

Problem This Feature Solves

Activity

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions