basic-memory 0.12.2__py3-none-any.whl → 0.13.0__py3-none-any.whl

basic_memory/mcp/prompts/__init__.py

@@ -10,10 +10,12 @@ from basic_memory.mcp.prompts import continue_conversation
 from basic_memory.mcp.prompts import recent_activity
 from basic_memory.mcp.prompts import search
 from basic_memory.mcp.prompts import ai_assistant_guide
+from basic_memory.mcp.prompts import sync_status
 
 __all__ = [
     "ai_assistant_guide",
     "continue_conversation",
     "recent_activity",
     "search",
+    "sync_status",
 ]

basic_memory/mcp/prompts/continue_conversation.py

@@ -4,20 +4,17 @@ These prompts help users continue conversations and work across sessions,
 providing context from previous interactions to maintain continuity.
 """
 
-from textwrap import dedent
 from typing import Annotated, Optional
 
 from loguru import logger
 from pydantic import Field
 
-from basic_memory.mcp.prompts.utils import PromptContext, PromptContextItem, format_prompt_context
+from basic_memory.config import get_project_config
+from basic_memory.mcp.async_client import client
 from basic_memory.mcp.server import mcp
-from basic_memory.mcp.tools.build_context import build_context
-from basic_memory.mcp.tools.recent_activity import recent_activity
-from basic_memory.mcp.tools.search import search_notes
+from basic_memory.mcp.tools.utils import call_post
 from basic_memory.schemas.base import TimeFrame
-from basic_memory.schemas.memory import GraphContext
-from basic_memory.schemas.search import SearchItemType
+from basic_memory.schemas.prompt import ContinueConversationRequest
 
 
 @mcp.prompt(
@@ -45,67 +42,20 @@ async def continue_conversation(
     """
     logger.info(f"Continuing session, topic: {topic}, timeframe: {timeframe}")
 
-    # If topic provided, search for it
-    if topic:
-        search_results = await search_notes(
-            query=topic, after_date=timeframe, entity_types=[SearchItemType.ENTITY]
-        )
+    # Create request model
+    request = ContinueConversationRequest(  # pyright: ignore [reportCallIssue]
+        topic=topic, timeframe=timeframe
+    )
 
-        # Build context from results
-        contexts = []
-        for result in search_results.results:
-            if hasattr(result, "permalink") and result.permalink:
-                context: GraphContext = await build_context(f"memory://{result.permalink}")
-                if context.primary_results:
-                    contexts.append(
-                        PromptContextItem(
-                            primary_results=context.primary_results[:1],  # pyright: ignore
-                            related_results=context.related_results[:3],  # pyright: ignore
-                        )
-                    )
+    project_url = get_project_config().project_url
 
-        # get context for the top 3 results
-        prompt_context = format_prompt_context(
-            PromptContext(topic=topic, timeframe=timeframe, results=contexts)  # pyright: ignore
-        )
+    # Call the prompt API endpoint
+    response = await call_post(
+        client,
+        f"{project_url}/prompt/continue-conversation",
+        json=request.model_dump(exclude_none=True),
+    )
 
-    else:
-        # If no topic, get recent activity
-        timeframe = timeframe or "7d"
-        recent: GraphContext = await recent_activity(
-            timeframe=timeframe, type=[SearchItemType.ENTITY]
-        )
-        prompt_context = format_prompt_context(
-            PromptContext(
-                topic=f"Recent Activity from ({timeframe})",
-                timeframe=timeframe,
-                results=[
-                    PromptContextItem(
-                        primary_results=recent.primary_results[:5],  # pyright: ignore
-                        related_results=recent.related_results[:2],  # pyright: ignore
-                    )
-                ],
-            )
-        )
-
-    # Add next steps with strong encouragement to write
-    next_steps = dedent(f"""
-        ## Next Steps
-
-        You can:
-        - Explore more with: `search_notes({{"text": "{topic}"}})`
-        - See what's changed: `recent_activity(timeframe="{timeframe or "7d"}")`
-        - **Record new learnings or decisions from this conversation:** `write_note(title="[Create a meaningful title]", content="[Content with observations and relations]")`
-        
-        ## Knowledge Capture Recommendation
-        
-        As you continue this conversation, **actively look for opportunities to:**
-        1. Record key information, decisions, or insights that emerge
-        2. Link new knowledge to existing topics 
-        3. Suggest capturing important context when appropriate
-        4. Create forward references to topics that might be created later
-        
-        Remember that capturing knowledge during conversations is one of the most valuable aspects of Basic Memory.
-        """)
-
-    return prompt_context + next_steps
+    # Extract the rendered prompt from the response
+    result = response.json()
+    return result["prompt"]

basic_memory/mcp/prompts/recent_activity.py

@@ -38,7 +38,19 @@ async def recent_activity_prompt(
     """
     logger.info(f"Getting recent activity, timeframe: {timeframe}")
 
-    recent = await recent_activity(timeframe=timeframe, type=[SearchItemType.ENTITY])
+    recent = await recent_activity.fn(timeframe=timeframe, type=[SearchItemType.ENTITY])
+
+    # Extract primary results from the hierarchical structure
+    primary_results = []
+    related_results = []
+
+    if recent.results:
+        # Take up to 5 primary results
+        for item in recent.results[:5]:
+            primary_results.append(item.primary_result)
+            # Add up to 2 related results per primary item
+            if item.related_results:
+                related_results.extend(item.related_results[:2])
 
     prompt_context = format_prompt_context(
         PromptContext(
@@ -46,14 +58,18 @@ async def recent_activity_prompt(
             timeframe=timeframe,
             results=[
                 PromptContextItem(
-                    primary_results=recent.primary_results[:5],
-                    related_results=recent.related_results[:2],
+                    primary_results=primary_results,
+                    related_results=related_results[:10],  # Limit total related results
                 )
             ],
         )
     )
 
     # Add suggestions for summarizing recent activity
+    first_title = "Recent Topic"
+    if primary_results and len(primary_results) > 0:
+        first_title = primary_results[0].title
+
     capture_suggestions = f"""
     ## Opportunity to Capture Activity Summary
     
@@ -76,7 +92,7 @@ async def recent_activity_prompt(
         - [insight] [Connection between different activities]
         
         ## Relations
-        - summarizes [[{recent.primary_results[0].title if recent.primary_results else "Recent Topic"}]]
+        - summarizes [[{first_title}]]
         - relates_to [[Project Overview]]
         '''
     )

basic_memory/mcp/prompts/search.py

@@ -3,16 +3,17 @@
 These prompts help users search and explore their knowledge base.
 """
 
-from textwrap import dedent
 from typing import Annotated, Optional
 
 from loguru import logger
 from pydantic import Field
 
+from basic_memory.config import get_project_config
+from basic_memory.mcp.async_client import client
 from basic_memory.mcp.server import mcp
-from basic_memory.mcp.tools.search import search_notes as search_tool
+from basic_memory.mcp.tools.utils import call_post
 from basic_memory.schemas.base import TimeFrame
-from basic_memory.schemas.search import SearchResponse
+from basic_memory.schemas.prompt import SearchPromptRequest
 
 
 @mcp.prompt(
@@ -40,143 +41,16 @@ async def search_prompt(
     """
     logger.info(f"Searching knowledge base, query: {query}, timeframe: {timeframe}")
 
-    search_results = await search_tool(query=query, after_date=timeframe)
-    return format_search_results(query, search_results, timeframe)
+    # Create request model
+    request = SearchPromptRequest(query=query, timeframe=timeframe)
 
+    project_url = get_project_config().project_url
 
-def format_search_results(
-    query: str, results: SearchResponse, timeframe: Optional[TimeFrame] = None
-) -> str:
-    """Format search results into a helpful summary.
-
-    Args:
-        query: The search query
-        results: Search results object
-        timeframe: How far back results were searched
-
-    Returns:
-        Formatted search results summary
-    """
-    if not results.results:
-        return dedent(f"""
-            # Search Results for: "{query}"
-            
-            I couldn't find any results for this query.
-            
-            ## Opportunity to Capture Knowledge!
-            
-            This is an excellent opportunity to create new knowledge on this topic. Consider:
-            
-            ```python
-            await write_note(
-                title="{query.capitalize()}",
-                content=f'''
-                # {query.capitalize()}
-                
-                ## Overview
-                [Summary of what we've discussed about {query}]
-                
-                ## Observations
-                - [category] [First observation about {query}]
-                - [category] [Second observation about {query}]
-                
-                ## Relations
-                - relates_to [[Other Relevant Topic]]
-                '''
-            )
-            ```
-            
-            ## Other Suggestions
-            - Try a different search term
-            - Broaden your search criteria
-            - Check recent activity with `recent_activity(timeframe="1w")`
-            """)
-
-    # Start building our summary with header
-    time_info = f" (after {timeframe})" if timeframe else ""
-    summary = dedent(f"""
-        # Search Results for: "{query}"{time_info}
-        
-        This is a memory search session.
-        Please use the available basic-memory tools to gather relevant context before responding.
-        I found {len(results.results)} results that match your query.
-        
-        Here are the most relevant results:
-        """)
-
-    # Add each search result
-    for i, result in enumerate(results.results[:5]):  # Limit to top 5 results
-        summary += dedent(f"""
-            ## {i + 1}. {result.title}
-            - **Type**: {result.type.value}
-            """)
-
-        # Add creation date if available in metadata
-        if result.metadata and "created_at" in result.metadata:
-            created_at = result.metadata["created_at"]
-            if hasattr(created_at, "strftime"):
-                summary += (
-                    f"- **Created**: {created_at.strftime('%Y-%m-%d %H:%M')}\n"  # pragma: no cover
-                )
-            elif isinstance(created_at, str):
-                summary += f"- **Created**: {created_at}\n"
-
-        # Add score and excerpt
-        summary += f"- **Relevance Score**: {result.score:.2f}\n"
-
-        # Add excerpt if available in metadata
-        if result.content:
-            summary += f"- **Excerpt**:\n{result.content}\n"
-
-        # Add permalink for retrieving content
-        if result.permalink:
-            summary += dedent(f"""
-                You can view this content with: `read_note("{result.permalink}")`
-                Or explore its context with: `build_context("memory://{result.permalink}")`
-                """)
-        else:
-            summary += dedent(f"""
-                You can view this file with: `read_file("{result.file_path}")`
-                """)  # pragma: no cover
-
-    # Add next steps with strong write encouragement
-    summary += dedent(f"""
-        ## Next Steps
-        
-        You can:
-        - Refine your search: `search_notes("{query} AND additional_term")`
-        - Exclude terms: `search_notes("{query} NOT exclude_term")`
-        - View more results: `search_notes("{query}", after_date=None)`
-        - Check recent activity: `recent_activity()`
-        
-        ## Synthesize and Capture Knowledge
-        
-        Consider creating a new note that synthesizes what you've learned:
-        
-        ```python
-        await write_note(
-            title="Synthesis of {query.capitalize()} Information",
-            content='''
-            # Synthesis of {query.capitalize()} Information
-            
-            ## Overview
-            [Synthesis of the search results and your conversation]
-            
-            ## Key Insights
-            [Summary of main points learned from these results]
-            
-            ## Observations
-            - [insight] [Important observation from search results]
-            - [connection] [How this connects to other topics]
-            
-            ## Relations
-            - relates_to [[{results.results[0].title if results.results else "Related Topic"}]]
-            - extends [[Another Relevant Topic]]
-            '''
-        )
-        ```
-        
-        Remember that capturing synthesized knowledge is one of the most valuable features of Basic Memory.
-        """)
+    # Call the prompt API endpoint
+    response = await call_post(
+        client, f"{project_url}/prompt/search", json=request.model_dump(exclude_none=True)
+    )
 
-    return summary
+    # Extract the rendered prompt from the response
+    result = response.json()
+    return result["prompt"]

basic_memory/mcp/prompts/sync_status.py

@@ -0,0 +1,116 @@
+"""Sync status prompt for Basic Memory MCP server."""
+
+from basic_memory.mcp.server import mcp
+
+
+@mcp.prompt(
+    description="""Get sync status with recommendations for AI assistants.
+    
+    This prompt provides both current sync status and guidance on how
+    AI assistants should respond when sync operations are in progress or completed.
+    """,
+)
+async def sync_status_prompt() -> str:
+    """Get sync status with AI assistant guidance.
+
+    This prompt provides detailed sync status information along with
+    recommendations for how AI assistants should handle different sync states.
+
+    Returns:
+        Formatted sync status with AI assistant guidance
+    """
+    try:  # pragma: no cover
+        from basic_memory.services.migration_service import migration_manager
+
+        state = migration_manager.state
+
+        # Build status report
+        lines = [
+            "# Basic Memory Sync Status",
+            "",
+            f"**Current Status**: {state.status.value.replace('_', ' ').title()}",
+            f"**System Ready**: {'Yes' if migration_manager.is_ready else 'No'}",
+            "",
+        ]
+
+        if migration_manager.is_ready:
+            lines.extend(
+                [
+                    "✅ **All sync operations completed** - System is fully operational",
+                    "",
+                    "All Basic Memory tools are available and functioning normally.",
+                    "File indexing is complete and knowledge graphs are up to date.",
+                    "You can proceed with any knowledge management tasks.",
+                ]
+            )
+        else:
+            lines.append(f"**Status Message**: {state.message}")
+
+            if state.status.value == "in_progress":
+                if state.projects_total > 0:
+                    progress = f" ({state.projects_migrated}/{state.projects_total})"
+                    lines.append(f"**Progress**: {progress}")
+
+                lines.extend(
+                    [
+                        "",
+                        "🔄 **File synchronization in progress** - Processing files and building knowledge graphs",
+                        "",
+                        "**Impact**: Some tools may show status messages instead of normal responses",
+                        "until sync completes (usually 1-3 minutes).",
+                    ]
+                )
+
+            elif state.status.value == "failed":
+                lines.extend(
+                    [
+                        "",
+                        f"❌ **Sync failed**: {state.error or 'Unknown error'}",
+                        "",
+                        "**Impact**: System may have limited functionality until issue is resolved.",
+                    ]
+                )
+
+        # Add AI assistant recommendations
+        if not migration_manager.is_ready:
+            lines.extend(
+                [
+                    "",
+                    "---",
+                    "",
+                    "## AI Assistant Recommendations",
+                    "",
+                    "**When sync is in progress:**",
+                    "- Inform the user about the background file processing",
+                    "- Suggest using `sync_status()` tool to check progress",
+                    "- Explain that tools will work normally once sync completes",
+                    "- Avoid creating complex workflows until sync is done",
+                    "",
+                    "**What to tell users:**",
+                    "- 'Basic Memory is processing your files and building knowledge graphs'",
+                    "- 'This usually takes 1-3 minutes depending on your content size'",
+                    "- 'You can check progress anytime with the sync_status tool'",
+                    "- 'Full functionality will be available once processing completes'",
+                    "",
+                    "**User-friendly language:**",
+                    "- Say 'processing files' instead of 'migration' or 'sync'",
+                    "- Say 'building knowledge graphs' instead of 'indexing'",
+                    "- Say 'setting up your knowledge base' instead of 'running migrations'",
+                ]
+            )
+
+        return "\n".join(lines)
+
+    except Exception as e:  # pragma: no cover
+        return f"""# Sync Status - Error
+
+❌ **Unable to check sync status**: {str(e)}
+
+## AI Assistant Recommendations
+
+**When status is unavailable:**
+- Assume the system is likely working normally
+- Try proceeding with normal operations
+- If users report issues, suggest checking logs or restarting
+- Use user-friendly language about 'setting up the knowledge base'
+"""

basic_memory/mcp/prompts/utils.py

@@ -35,7 +35,7 @@ def format_prompt_context(context: PromptContext) -> str:
     Returns:
         Formatted continuation summary
     """
-    if not context.results:
+    if not context.results:  # pragma: no cover
         return dedent(f"""
             # Continuing conversation on: {context.topic}
 
@@ -138,11 +138,11 @@ def format_prompt_context(context: PromptContext) -> str:
                     - type: **{related.type}**
                     - title: {related.title}
                     """)
-                if related.permalink:
+                if related.permalink:  # pragma: no cover
                     section_content += (
                         f'You can view this document with: `read_note("{related.permalink}")`'
                     )
-                else:
+                else:  # pragma: no cover
                     section_content += (
                         f'You can view this file with: `read_file("{related.file_path}")`'
                     )

basic_memory/mcp/{tools → resources}/project_info.py

@@ -2,13 +2,15 @@
 
 from loguru import logger
 
+from basic_memory.mcp.project_session import get_active_project
 from basic_memory.mcp.async_client import client
 from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.utils import call_get
 from basic_memory.schemas import ProjectInfoResponse
 
 
-@mcp.tool(
+@mcp.resource(
+    uri="memory://project_info",
     description="Get information and statistics about the current Basic Memory project.",
 )
 async def project_info() -> ProjectInfoResponse:
@@ -43,9 +45,11 @@ async def project_info() -> ProjectInfoResponse:
         print(f"Basic Memory version: {info.system.version}")
     """
     logger.info("Getting project info")
+    project_config = get_active_project()
+    project_url = project_config.project_url
 
     # Call the API endpoint
-    response = await call_get(client, "/stats/project-info")
+    response = await call_get(client, f"{project_url}/project/info")
 
     # Convert response to ProjectInfoResponse
     return ProjectInfoResponse.model_validate(response.json())

basic_memory/mcp/server.py

@@ -1,37 +1,110 @@
-"""Enhanced FastMCP server instance for Basic Memory."""
+"""
+Basic Memory FastMCP server.
+"""
 
 import asyncio
 from contextlib import asynccontextmanager
-from typing import AsyncIterator, Optional
-
-from mcp.server.fastmcp import FastMCP
-from mcp.server.fastmcp.utilities.logging import configure_logging as mcp_configure_logging
 from dataclasses import dataclass
+from typing import AsyncIterator, Optional, Any
+
+from dotenv import load_dotenv
+from fastmcp import FastMCP
+from fastmcp.utilities.logging import configure_logging as mcp_configure_logging
+from mcp.server.auth.settings import AuthSettings
 
-from basic_memory.config import config as project_config
+from basic_memory.config import app_config
 from basic_memory.services.initialization import initialize_app
+from basic_memory.mcp.auth_provider import BasicMemoryOAuthProvider
+from basic_memory.mcp.project_session import session
+from basic_memory.mcp.external_auth_provider import (
+    create_github_provider,
+    create_google_provider,
+)
+from basic_memory.mcp.supabase_auth_provider import SupabaseOAuthProvider
 
 # mcp console logging
 mcp_configure_logging(level="ERROR")
 
+load_dotenv()
+
 
 @dataclass
 class AppContext:
     watch_task: Optional[asyncio.Task]
+    migration_manager: Optional[Any] = None
 
 
 @asynccontextmanager
 async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:  # pragma: no cover
     """Manage application lifecycle with type-safe context"""
-    # Initialize on startup
-    watch_task = await initialize_app(project_config)
+    # Initialize on startup (now returns migration_manager)
+    migration_manager = await initialize_app(app_config)
+
+    # Initialize project session with default project
+    session.initialize(app_config.default_project)
+
     try:
-        yield AppContext(watch_task=watch_task)
+        yield AppContext(watch_task=None, migration_manager=migration_manager)
     finally:
-        # Cleanup on shutdown
-        if watch_task:
-            watch_task.cancel()
+        # Cleanup on shutdown - migration tasks will be cancelled automatically
+        pass
+
+
+# OAuth configuration function
+def create_auth_config() -> tuple[AuthSettings | None, Any | None]:
+    """Create OAuth configuration if enabled."""
+    # Check if OAuth is enabled via environment variable
+    import os
+
+    if os.getenv("FASTMCP_AUTH_ENABLED", "false").lower() == "true":
+        from pydantic import AnyHttpUrl
+
+        # Configure OAuth settings
+        issuer_url = os.getenv("FASTMCP_AUTH_ISSUER_URL", "http://localhost:8000")
+        required_scopes = os.getenv("FASTMCP_AUTH_REQUIRED_SCOPES", "read,write")
+        docs_url = os.getenv("FASTMCP_AUTH_DOCS_URL") or "http://localhost:8000/docs/oauth"
+
+        auth_settings = AuthSettings(
+            issuer_url=AnyHttpUrl(issuer_url),
+            service_documentation_url=AnyHttpUrl(docs_url),
+            required_scopes=required_scopes.split(",") if required_scopes else ["read", "write"],
+        )
+
+        # Create OAuth provider based on type
+        provider_type = os.getenv("FASTMCP_AUTH_PROVIDER", "basic").lower()
+
+        if provider_type == "github":
+            auth_provider = create_github_provider()
+        elif provider_type == "google":
+            auth_provider = create_google_provider()
+        elif provider_type == "supabase":
+            supabase_url = os.getenv("SUPABASE_URL")
+            supabase_anon_key = os.getenv("SUPABASE_ANON_KEY")
+            supabase_service_key = os.getenv("SUPABASE_SERVICE_KEY")
+
+            if not supabase_url or not supabase_anon_key:
+                raise ValueError("SUPABASE_URL and SUPABASE_ANON_KEY must be set for Supabase auth")
+
+            auth_provider = SupabaseOAuthProvider(
+                supabase_url=supabase_url,
+                supabase_anon_key=supabase_anon_key,
+                supabase_service_key=supabase_service_key,
+                issuer_url=issuer_url,
+            )
+        else:  # default to "basic"
+            auth_provider = BasicMemoryOAuthProvider(issuer_url=issuer_url)
+
+        return auth_settings, auth_provider
+
+    return None, None
+
 
+# Create auth configuration
+auth_settings, auth_provider = create_auth_config()
 
 # Create the shared server instance
-mcp = FastMCP("Basic Memory", log_level="ERROR", lifespan=app_lifespan)
+mcp = FastMCP(
+    name="Basic Memory",
+    log_level="DEBUG",
+    auth=auth_provider,
+)