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

basic_memory/mcp/tools/search.py

@@ -4,15 +4,18 @@ from textwrap import dedent
 from typing import List, Optional
 
 from loguru import logger
+from fastmcp import Context
 
 from basic_memory.mcp.async_client import 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_post
-from basic_memory.mcp.project_session import get_active_project
 from basic_memory.schemas.search import SearchItemType, SearchQuery, SearchResponse
 
 
-def _format_search_error_response(error_message: str, query: str, search_type: str = "text") -> str:
+def _format_search_error_response(
+    project: str, error_message: str, query: str, search_type: str = "text"
+) -> str:
     """Format helpful error responses for search failures that guide users to successful searches."""
 
     # FTS5 syntax errors
@@ -50,13 +53,13 @@ def _format_search_error_response(error_message: str, query: str, search_type: s
 
             ## Try again with:
             ```
-            search_notes("{clean_query}")
+            search_notes("{project}","{clean_query}")
             ```
 
             ## Alternative search strategies:
-            - Break into simpler terms: `search_notes("{" ".join(clean_query.split()[:2])}")`
-            - Try different search types: `search_notes("{clean_query}", search_type="title")`
-            - Use filtering: `search_notes("{clean_query}", types=["entity"])`
+            - Break into simpler terms: `search_notes("{project}", "{" ".join(clean_query.split()[:2])}")`
+            - Try different search types: `search_notes("{project}","{clean_query}", search_type="title")`
+            - Use filtering: `search_notes("{project}","{clean_query}", types=["entity"])`
             """).strip()
 
     # Project not found errors (check before general "not found")
@@ -68,11 +71,9 @@ def _format_search_error_response(error_message: str, query: str, search_type: s
 
             ## How to resolve:
             1. **Check available projects**: `list_projects()`
-            2. **Switch to valid project**: `switch_project("valid-project-name")`
             3. **Verify project setup**: Ensure your project is properly configured
 
             ## Current session info:
-            - Check current project: `get_current_project()`
             - See available projects: `list_projects()`
             """).strip()
 
@@ -100,29 +101,28 @@ def _format_search_error_response(error_message: str, query: str, search_type: s
                - Try synonyms or related terms
 
             3. **Use different search approaches**:
-               - **Text search**: `search_notes("{query}", search_type="text")` (searches full content)
-               - **Title search**: `search_notes("{query}", search_type="title")` (searches only titles)
-               - **Permalink search**: `search_notes("{query}", search_type="permalink")` (searches file paths)
+               - **Text search**: `search_notes("{project}","{query}", search_type="text")` (searches full content)
+               - **Title search**: `search_notes("{project}","{query}", search_type="title")` (searches only titles)
+               - **Permalink search**: `search_notes("{project}","{query}", search_type="permalink")` (searches file paths)
 
             4. **Try boolean operators for broader results**:
-               - OR search: `search_notes("{" OR ".join(query.split()[:3])}")`
+               - OR search: `search_notes("{project}","{" OR ".join(query.split()[:3])}")`
                - Remove restrictive terms: Focus on the most important keywords
 
             5. **Use filtering to narrow scope**:
-               - By content type: `search_notes("{query}", types=["entity"])`
-               - By recent content: `search_notes("{query}", after_date="1 week")`
-               - By entity type: `search_notes("{query}", entity_types=["observation"])`
+               - By content type: `search_notes("{project}","{query}", types=["entity"])`
+               - By recent content: `search_notes("{project}","{query}", after_date="1 week")`
+               - By entity type: `search_notes("{project}","{query}", entity_types=["observation"])`
 
             6. **Try advanced search patterns**:
-               - Tag search: `search_notes("tag:your-tag")`
-               - Category search: `search_notes("category:observation")`
-               - Pattern matching: `search_notes("*{query}*", search_type="permalink")`
+               - Tag search: `search_notes("{project}","tag:your-tag")`
+               - Category search: `search_notes("{project}","category:observation")`
+               - Pattern matching: `search_notes("{project}","*{query}*", search_type="permalink")`
 
             ## Explore what content exists:
             - **Recent activity**: `recent_activity(timeframe="7d")` - See what's been updated recently
-            - **List directories**: `list_directory("/")` - Browse all content
-            - **Browse by folder**: `list_directory("/notes")` or `list_directory("/docs")`
-            - **Check project**: `get_current_project()` - Verify you're in the right project
+            - **List directories**: `list_directory("{project}","/")` - Browse all content
+            - **Browse by folder**: `list_directory("{project}","/notes")` or `list_directory("/docs")`
             """).strip()
 
     # Server/API errors
@@ -138,9 +138,9 @@ def _format_search_error_response(error_message: str, query: str, search_type: s
             3. **Check project status**: Ensure your project is properly synced
 
             ## Alternative approaches:
-            - Browse files directly: `list_directory("/")`
+            - Browse files directly: `list_directory("{project}","/")`
             - Check recent activity: `recent_activity(timeframe="7d")`
-            - Try a different search type: `search_notes("{query}", search_type="title")`
+            - Try a different search type: `search_notes("{project}","{query}", search_type="title")`
 
             ## If the problem persists:
             The search index might need to be rebuilt. Send a message to support@basicmachines.co or check the project sync status.
@@ -162,9 +162,7 @@ You don't have permission to search in the current project: {error_message}
 3. **Check authentication**: You might need to re-authenticate
 
 ## Alternative actions:
-- List available projects: `list_projects()`
-- Switch to accessible project: `switch_project("project-name")`
-- Check current project: `get_current_project()`"""
+- List available projects: `list_projects()`"""
 
     # Generic fallback
     return f"""# Search Failed
@@ -179,17 +177,16 @@ Error searching for '{query}': {error_message}
 
 ## Alternative search approaches:
 - **Different search types**: 
-  - Title only: `search_notes("{query}", search_type="title")`
-  - Permalink patterns: `search_notes("{query}*", search_type="permalink")`
-- **With filters**: `search_notes("{query}", types=["entity"])`
-- **Recent content**: `search_notes("{query}", after_date="1 week")`
-- **Boolean variations**: `search_notes("{" OR ".join(query.split()[:2])}")`
+  - Title only: `search_notes("{project}","{query}", search_type="title")`
+  - Permalink patterns: `search_notes("{project}","{query}*", search_type="permalink")`
+- **With filters**: `search_notes("{project}","{query}", types=["entity"])`
+- **Recent content**: `search_notes("{project}","{query}", after_date="1 week")`
+- **Boolean variations**: `search_notes("{project}","{" OR ".join(query.split()[:2])}")`
 
 ## Explore your content:
-- **Browse files**: `list_directory("/")` - See all available content
+- **Browse files**: `list_directory("{project}","/")` - See all available content
 - **Recent activity**: `recent_activity(timeframe="7d")` - Check what's been updated
-- **Project info**: `get_current_project()` - Verify current project
-- **All projects**: `list_projects()` - Switch to different project if needed
+- **All projects**: `list_projects()` 
 
 ## Search syntax reference:
 - **Basic**: `keyword` or `multiple words`
@@ -204,13 +201,14 @@ Error searching for '{query}': {error_message}
 )
 async def search_notes(
     query: str,
+    project: Optional[str] = None,
     page: int = 1,
     page_size: int = 10,
     search_type: str = "text",
     types: Optional[List[str]] = None,
     entity_types: Optional[List[str]] = None,
     after_date: Optional[str] = None,
-    project: Optional[str] = None,
+    context: Context | None = None,
 ) -> SearchResponse | str:
     """Search across all content in the knowledge base with comprehensive syntax support.
 
@@ -218,51 +216,57 @@ async def search_notes(
     or exact permalink lookup. It supports filtering by content type, entity type,
     and date, with advanced boolean and phrase search capabilities.
 
+    Project Resolution:
+    Server resolves projects in this order: Single Project Mode → project parameter → default project.
+    If project unknown, use list_memory_projects() or recent_activity() first.
+
     ## Search Syntax Examples
 
     ### Basic Searches
-    - `search_notes("keyword")` - Find any content containing "keyword"
-    - `search_notes("exact phrase")` - Search for exact phrase match
+    - `search_notes("my-project", "keyword")` - Find any content containing "keyword"
+    - `search_notes("work-docs", "'exact phrase'")` - Search for exact phrase match
 
     ### Advanced Boolean Searches
-    - `search_notes("term1 term2")` - Find content with both terms (implicit AND)
-    - `search_notes("term1 AND term2")` - Explicit AND search (both terms required)
-    - `search_notes("term1 OR term2")` - Either term can be present
-    - `search_notes("term1 NOT term2")` - Include term1 but exclude term2
-    - `search_notes("(project OR planning) AND notes")` - Grouped boolean logic
+    - `search_notes("my-project", "term1 term2")` - Find content with both terms (implicit AND)
+    - `search_notes("my-project", "term1 AND term2")` - Explicit AND search (both terms required)
+    - `search_notes("my-project", "term1 OR term2")` - Either term can be present
+    - `search_notes("my-project", "term1 NOT term2")` - Include term1 but exclude term2
+    - `search_notes("my-project", "(project OR planning) AND notes")` - Grouped boolean logic
 
     ### Content-Specific Searches
-    - `search_notes("tag:example")` - Search within specific tags (if supported by content)
-    - `search_notes("category:observation")` - Filter by observation categories
-    - `search_notes("author:username")` - Find content by author (if metadata available)
+    - `search_notes("research", "tag:example")` - Search within specific tags (if supported by content)
+    - `search_notes("work-project", "category:observation")` - Filter by observation categories
+    - `search_notes("team-docs", "author:username")` - Find content by author (if metadata available)
 
     ### Search Type Examples
-    - `search_notes("Meeting", search_type="title")` - Search only in titles
-    - `search_notes("docs/meeting-*", search_type="permalink")` - Pattern match permalinks
-    - `search_notes("keyword", search_type="text")` - Full-text search (default)
+    - `search_notes("my-project", "Meeting", search_type="title")` - Search only in titles
+    - `search_notes("work-docs", "docs/meeting-*", search_type="permalink")` - Pattern match permalinks
+    - `search_notes("research", "keyword", search_type="text")` - Full-text search (default)
 
     ### Filtering Options
-    - `search_notes("query", types=["entity"])` - Search only entities
-    - `search_notes("query", types=["note", "person"])` - Multiple content types
-    - `search_notes("query", entity_types=["observation"])` - Filter by entity type
-    - `search_notes("query", after_date="2024-01-01")` - Recent content only
-    - `search_notes("query", after_date="1 week")` - Relative date filtering
+    - `search_notes("my-project", "query", types=["entity"])` - Search only entities
+    - `search_notes("work-docs", "query", types=["note", "person"])` - Multiple content types
+    - `search_notes("research", "query", entity_types=["observation"])` - Filter by entity type
+    - `search_notes("team-docs", "query", after_date="2024-01-01")` - Recent content only
+    - `search_notes("my-project", "query", after_date="1 week")` - Relative date filtering
 
     ### Advanced Pattern Examples
-    - `search_notes("project AND (meeting OR discussion)")` - Complex boolean logic
-    - `search_notes("\"exact phrase\" AND keyword")` - Combine phrase and keyword search
-    - `search_notes("bug NOT fixed")` - Exclude resolved issues
-    - `search_notes("docs/2024-*", search_type="permalink")` - Year-based permalink search
+    - `search_notes("work-project", "project AND (meeting OR discussion)")` - Complex boolean logic
+    - `search_notes("research", "\"exact phrase\" AND keyword")` - Combine phrase and keyword search
+    - `search_notes("dev-notes", "bug NOT fixed")` - Exclude resolved issues
+    - `search_notes("archive", "docs/2024-*", search_type="permalink")` - Year-based permalink search
 
     Args:
         query: The search query string (supports boolean operators, phrases, patterns)
+        project: Project name to search in. Optional - server will resolve using hierarchy.
+                If unknown, use list_memory_projects() to discover available projects.
         page: The page number of results to return (default 1)
         page_size: The number of results to return per page (default 10)
         search_type: Type of search to perform, one of: "text", "title", "permalink" (default: "text")
         types: Optional list of note types to search (e.g., ["note", "person"])
         entity_types: Optional list of entity types to filter by (e.g., ["entity", "observation"])
         after_date: Optional date filter for recent content (e.g., "1 week", "2d", "2024-01-01")
-        project: Optional project name to search in. If not provided, uses current active project.
+        context: Optional FastMCP context for performance caching.
 
     Returns:
         SearchResponse with results and pagination info, or helpful error guidance if search fails
@@ -288,37 +292,43 @@ async def search_notes(
 
         # Search with type filter
         results = await search_notes(
-            query="meeting notes",
+            "meeting notes",
             types=["entity"],
         )
 
         # Search with entity type filter
         results = await search_notes(
-            query="meeting notes",
+            "meeting notes",
             entity_types=["observation"],
         )
 
         # Search for recent content
         results = await search_notes(
-            query="bug report",
+            "bug report",
             after_date="1 week"
         )
 
         # Pattern matching on permalinks
         results = await search_notes(
-            query="docs/meeting-*",
+            "docs/meeting-*",
             search_type="permalink"
         )
 
-        # Search in specific project
-        results = await search_notes("meeting notes", project="work-project")
+        # Title-only search
+        results = await search_notes(
+            "Machine Learning",
+            search_type="title"
+        )
 
         # Complex search with multiple filters
         results = await search_notes(
-            query="(bug OR issue) AND NOT resolved",
+            "(bug OR issue) AND NOT resolved",
             types=["entity"],
             after_date="2024-01-01"
         )
+
+        # Explicit project specification
+        results = await search_notes("project planning", project="my-project")
     """
     # Create a SearchQuery object based on the parameters
     search_query = SearchQuery()
@@ -343,10 +353,10 @@ async def search_notes(
     if after_date:
         search_query.after_date = after_date
 
-    active_project = get_active_project(project)
+    active_project = await get_active_project(client, project, context)
     project_url = active_project.project_url
 
-    logger.info(f"Searching for {search_query}")
+    logger.info(f"Searching for {search_query} in project {active_project.name}")
 
     try:
         response = await call_post(
@@ -359,13 +369,15 @@ async def search_notes(
 
         # Check if we got no results and provide helpful guidance
         if not result.results:
-            logger.info(f"Search returned no results for query: {query}")
+            logger.info(
+                f"Search returned no results for query: {query} in project {active_project.name}"
+            )
             # Don't treat this as an error, but the user might want guidance
             # We return the empty result as normal - the user can decide if they need help
 
         return result
 
     except Exception as e:
-        logger.error(f"Search failed for query '{query}': {e}")
+        logger.error(f"Search failed for query '{query}': {e}, project: {active_project.name}")
         # Return formatted error message as string for better user experience
-        return _format_search_error_response(str(e), query, search_type)
+        return _format_search_error_response(active_project.name, str(e), query, search_type)

basic_memory/mcp/tools/sync_status.py

@@ -3,10 +3,12 @@
 from typing import Optional
 
 from loguru import logger
+from fastmcp import Context
 
 from basic_memory.config import ConfigManager
+from basic_memory.mcp.async_client import client
 from basic_memory.mcp.server import mcp
-from basic_memory.mcp.project_session import get_active_project
+from basic_memory.mcp.project_context import get_active_project
 from basic_memory.services.sync_status_service import sync_status_tracker
 
 
@@ -79,7 +81,7 @@ def _get_all_projects_status() -> list[str]:
     - Background processing of knowledge graphs
     """,
 )
-async def sync_status(project: Optional[str] = None) -> str:
+async def sync_status(project: Optional[str] = None, context: Context | None = None) -> str:
     """Get current sync status and system readiness information.
 
     This tool provides detailed information about any ongoing or completed
@@ -220,14 +222,13 @@ async def sync_status(project: Optional[str] = None) -> str:
                     [
                         "",
                         "**Note**: All configured projects will be automatically synced during startup.",
-                        "You don't need to manually switch projects - Basic Memory handles this for you.",
                     ]
                 )
 
         # Add project context if provided
         if project:
             try:
-                active_project = get_active_project(project)
+                active_project = await get_active_project(client, project, context)
                 status_lines.extend(
                     [
                         "",

basic_memory/mcp/tools/utils.py

@@ -23,6 +23,8 @@ from httpx._types import (
 from loguru import logger
 from mcp.server.fastmcp.exceptions import ToolError
 
+from basic_memory.mcp.tools.headers import inject_auth_header
+
 
 def get_error_message(
     status_code: int, url: URL | str, method: str, msg: Optional[str] = None
@@ -107,6 +109,8 @@ async def call_get(
     """
     logger.debug(f"Calling GET '{url}' params: '{params}'")
     error_message = None
+
+    headers = inject_auth_header(headers)
     try:
         response = await client.get(
             url,
@@ -192,6 +196,9 @@ async def call_put(
     logger.debug(f"Calling PUT '{url}'")
     error_message = None
 
+    # Inject JWT from FastMCP context if available
+    headers = inject_auth_header(headers)
+
     try:
         response = await client.put(
             url,
@@ -280,6 +287,10 @@ async def call_patch(
         ToolError: If the request fails with an appropriate error message
     """
     logger.debug(f"Calling PATCH '{url}'")
+
+    # Inject JWT from FastMCP context if available
+    headers = inject_auth_header(headers)
+
     try:
         response = await client.patch(
             url,
@@ -384,6 +395,10 @@ async def call_post(
     """
     logger.debug(f"Calling POST '{url}'")
     error_message = None
+
+    # Inject JWT from FastMCP context if available
+    headers = inject_auth_header(headers)
+
     try:
         response = await client.post(
             url=url,
@@ -465,6 +480,10 @@ async def call_delete(
     """
     logger.debug(f"Calling DELETE '{url}'")
     error_message = None
+
+    # Inject JWT from FastMCP context if available
+    headers = inject_auth_header(headers)
+
     try:
         response = await client.delete(
             url=url,

basic_memory/mcp/tools/view_note.py

@@ -4,6 +4,7 @@ from textwrap import dedent
 from typing import Optional
 
 from loguru import logger
+from fastmcp import Context
 
 from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.read_note import read_note
@@ -13,12 +14,17 @@ from basic_memory.mcp.tools.read_note import read_note
     description="View a note as a formatted artifact for better readability.",
 )
 async def view_note(
-    identifier: str, page: int = 1, page_size: int = 10, project: Optional[str] = None
+    identifier: str,
+    project: Optional[str] = None,
+    page: int = 1,
+    page_size: int = 10,
+    context: Context | None = None,
 ) -> str:
     """View a markdown note as a formatted artifact.
 
     This tool reads a note using the same logic as read_note but displays the content
     as a markdown artifact for better viewing experience in Claude Desktop.
+    Project parameter optional with server resolution.
 
     After calling this tool, create an artifact using the returned content to display
     the note in a readable format. The tool returns the note content that should be
@@ -26,21 +32,40 @@ async def view_note(
 
     Args:
         identifier: The title or permalink of the note to view
+        project: Project name to read from. Optional - server will resolve using hierarchy.
+                If unknown, use list_memory_projects() to discover available projects.
         page: Page number for paginated results (default: 1)
         page_size: Number of items per page (default: 10)
-        project: Optional project name to read from. If not provided, uses current active project.
+        context: Optional FastMCP context for performance caching.
 
     Returns:
         The note content as a markdown artifact with a confirmation message.
+
+    Examples:
+        # View a note by title
+        view_note("Meeting Notes")
+
+        # View a note by permalink
+        view_note("meetings/weekly-standup")
+
+        # View with pagination
+        view_note("large-document", page=2, page_size=5)
+
+        # Explicit project specification
+        view_note("Meeting Notes", project="my-project")
+
+    Raises:
+        HTTPError: If project doesn't exist or is inaccessible
+        SecurityError: If identifier attempts path traversal
     """
 
-    logger.info(f"Viewing note: {identifier}")
+    logger.info(f"Viewing note: {identifier} in project: {project}")
 
     # Call the existing read_note logic
-    content = await read_note.fn(identifier, page, page_size, project)
+    content = await read_note.fn(identifier, project, page, page_size, context)
 
     # Check if this is an error message (note not found)
-    if "# Note Not Found:" in content:
+    if "# Note Not Found" in content:
         return content  # Return error message directly instead of creating artifact
 
     # Extract title from content if possible
@@ -61,6 +86,6 @@ async def view_note(
 
     return dedent(f"""
             <instructions>
-            Create an artifact using the returned artifact content to display the note in a readable format.
+            Create an artifact using the returned content to display the note in a readable format.
             </instructions>
             {artifact}\n\n✅ Note displayed as artifact: **{title}**""")

basic_memory/mcp/tools/write_note.py

@@ -5,10 +5,11 @@ from typing import List, Union, Optional
 from loguru import logger
 
 from basic_memory.mcp.async_client import 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_put
-from basic_memory.mcp.project_session import get_active_project
 from basic_memory.schemas import EntityResponse
+from fastmcp import Context
 from basic_memory.schemas.base import Entity
 from basic_memory.utils import parse_tags, validate_project_path
 
@@ -26,14 +27,20 @@ async def write_note(
     title: str,
     content: str,
     folder: str,
-    tags=None,  # Remove type hint completely to avoid schema issues
-    entity_type: str = "note",
     project: Optional[str] = None,
+    tags=None,
+    entity_type: str = "note",
+    context: Context | None = None,
 ) -> str:
     """Write a markdown note to the knowledge base.
 
-    The content can include semantic observations and relations using markdown syntax.
-    Relations can be specified either explicitly or through inline wiki-style links:
+    Creates or updates a markdown note with semantic observations and relations.
+
+    Project Resolution:
+    Server resolves projects in this order: Single Project Mode → project parameter → default project.
+    If project unknown, use list_memory_projects() or recent_activity() first.
+
+    The content can include semantic observations and relations using markdown syntax:
 
     Observations format:
         `- [category] Observation text #tag1 #tag2 (optional context)`
@@ -50,30 +57,72 @@ async def write_note(
         Examples:
         `- depends_on [[Content Parser]] (Need for semantic extraction)`
         `- implements [[Search Spec]] (Initial implementation)`
-        `- This feature extends [[Base Design]] andst uses [[Core Utils]]`
+        `- This feature extends [[Base Design]] and uses [[Core Utils]]`
 
     Args:
         title: The title of the note
         content: Markdown content for the note, can include observations and relations
         folder: Folder path relative to project root where the file should be saved.
                 Use forward slashes (/) as separators. Examples: "notes", "projects/2025", "research/ml"
+        project: Project name to write to. Optional - server will resolve using the
+                hierarchy above. If unknown, use list_memory_projects() to discover
+                available projects.
         tags: Tags to categorize the note. Can be a list of strings, a comma-separated string, or None.
               Note: If passing from external MCP clients, use a string format (e.g. "tag1,tag2,tag3")
         entity_type: Type of entity to create. Defaults to "note". Can be "guide", "report", "config", etc.
-        project: Optional project name to write to. If not provided, uses current active project.
+        context: Optional FastMCP context for performance caching.
 
     Returns:
         A markdown formatted summary of the semantic content, including:
-        - Creation/update status
+        - Creation/update status with project name
         - File path and checksum
         - Observation counts by category
         - Relation counts (resolved/unresolved)
         - Tags if present
+        - Session tracking metadata for project awareness
+
+    Examples:
+        # Assistant flow when project is unknown
+        # 1. list_memory_projects() -> Ask user which project
+        # 2. User: "Use my-research"
+        # 3. write_note(...) and remember "my-research" for session
+
+        # Create a simple note
+        write_note(
+            project="my-research",
+            title="Meeting Notes",
+            folder="meetings",
+            content="# Weekly Standup\\n\\n- [decision] Use SQLite for storage #tech"
+        )
+
+        # Create a note with tags and entity type
+        write_note(
+            project="work-project",
+            title="API Design",
+            folder="specs",
+            content="# REST API Specification\\n\\n- implements [[Authentication]]",
+            tags=["api", "design"],
+            entity_type="guide"
+        )
+
+        # Update existing note (same title/folder)
+        write_note(
+            project="my-research",
+            title="Meeting Notes",
+            folder="meetings",
+            content="# Weekly Standup\\n\\n- [decision] Use PostgreSQL instead #tech"
+        )
+
+    Raises:
+        HTTPError: If project doesn't exist or is inaccessible
+        SecurityError: If folder path attempts path traversal
     """
-    logger.info(f"MCP tool call tool=write_note folder={folder}, title={title}, tags={tags}")
+    logger.info(
+        f"MCP tool call tool=write_note project={project} folder={folder}, title={title}, tags={tags}"
+    )
 
-    # Get the active project first to check project-specific sync status
-    active_project = get_active_project(project)
+    # Get and validate the project (supports optional project parameter)
+    active_project = await get_active_project(client, project, context)
 
     # Validate folder path to prevent path traversal attacks
     project_path = active_project.home
@@ -104,7 +153,7 @@ async def write_note(
         content=content,
         entity_metadata=metadata,
     )
-    project_url = active_project.project_url
+    project_url = active_project.permalink
 
     # Create or update via knowledge API
     logger.debug(f"Creating entity via API permalink={entity.permalink}")
@@ -116,6 +165,7 @@ async def write_note(
     action = "Created" if response.status_code == 201 else "Updated"
     summary = [
         f"# {action} note",
+        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'}",
@@ -152,6 +202,7 @@ async def write_note(
 
     # Log the response with structured data
     logger.info(
-        f"MCP tool response: tool=write_note action={action} permalink={result.permalink} observations_count={len(result.observations)} relations_count={len(result.relations)} resolved_relations={resolved} unresolved_relations={unresolved} status_code={response.status_code}"
+        f"MCP tool response: tool=write_note project={active_project.name} action={action} permalink={result.permalink} observations_count={len(result.observations)} relations_count={len(result.relations)} resolved_relations={resolved} unresolved_relations={unresolved} status_code={response.status_code}"
     )
-    return "\n".join(summary)
+    result = "\n".join(summary)
+    return add_project_metadata(result, active_project.name)