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

basic_memory/mcp/tools/read_note.py

@@ -10,7 +10,7 @@ from basic_memory.mcp.async_client import get_client
 from basic_memory.mcp.project_context import get_active_project
 from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.search import search_notes
-from basic_memory.mcp.tools.utils import call_get
+from basic_memory.telemetry import track_mcp_tool
 from basic_memory.schemas.memory import memory_url_path
 from basic_memory.utils import validate_project_path
 
@@ -77,6 +77,7 @@ async def read_note(
         If the exact note isn't found, this tool provides helpful suggestions
         including related notes, search commands, and note creation templates.
     """
+    track_mcp_tool("read_note")
     async with get_client() as client:
         # Get and validate the project
         active_project = await get_active_project(client, project, context)
@@ -97,23 +98,32 @@ async def read_note(
             )
             return f"# Error\n\nIdentifier '{identifier}' is not allowed - paths must stay within project boundaries"
 
-        project_url = active_project.project_url
-
-        # Get the file via REST API - first try direct permalink lookup
+        # Get the file via REST API - first try direct identifier resolution
         entity_path = memory_url_path(identifier)
-        path = f"{project_url}/resource/{entity_path}"
-        logger.info(f"Attempting to read note from Project: {active_project.name} URL: {path}")
+        logger.info(
+            f"Attempting to read note from Project: {active_project.name} identifier: {entity_path}"
+        )
+
+        # Import here to avoid circular import
+        from basic_memory.mcp.clients import KnowledgeClient, ResourceClient
+
+        # Use typed clients for API calls
+        knowledge_client = KnowledgeClient(client, active_project.external_id)
+        resource_client = ResourceClient(client, active_project.external_id)
 
         try:
-            # Try direct lookup first
-            response = await call_get(client, path, params={"page": page, "page_size": page_size})
+            # Try to resolve identifier to entity ID
+            entity_id = await knowledge_client.resolve_entity(entity_path)
+
+            # Fetch content using entity ID
+            response = await resource_client.read(entity_id, page=page, page_size=page_size)
 
             # If successful, return the content
             if response.status_code == 200:
                 logger.info("Returning read_note result from resource: {path}", path=entity_path)
                 return response.text
         except Exception as e:  # pragma: no cover
-            logger.info(f"Direct lookup failed for '{path}': {e}")
+            logger.info(f"Direct lookup failed for '{entity_path}': {e}")
             # Continue to fallback methods
 
         # Fallback 1: Try title search via API
@@ -127,11 +137,11 @@ async def read_note(
             result = title_results.results[0]  # Get the first/best match
             if result.permalink:
                 try:
-                    # Try to fetch the content using the found permalink
-                    path = f"{project_url}/resource/{result.permalink}"
-                    response = await call_get(
-                        client, path, params={"page": page, "page_size": page_size}
-                    )
+                    # Resolve the permalink to entity ID
+                    entity_id = await knowledge_client.resolve_entity(result.permalink)
+
+                    # Fetch content using the entity ID
+                    response = await resource_client.read(entity_id, page=page, page_size=page_size)
 
                     if response.status_code == 200:
                         logger.info(f"Found note by title search: {result.permalink}")

basic_memory/mcp/tools/recent_activity.py

@@ -1,5 +1,6 @@
 """Recent activity tool for Basic Memory MCP server."""
 
+from datetime import timezone
 from typing import List, Union, Optional
 
 from loguru import logger
@@ -9,6 +10,7 @@ from basic_memory.mcp.async_client import get_client
 from basic_memory.mcp.project_context import get_active_project, resolve_project_parameter
 from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.utils import call_get
+from basic_memory.telemetry import track_mcp_tool
 from basic_memory.schemas.base import TimeFrame
 from basic_memory.schemas.memory import (
     GraphContext,
@@ -98,6 +100,7 @@ async def recent_activity(
         - For focused queries, consider using build_context with a specific URI
         - Max timeframe is 1 year in the past
     """
+    track_mcp_tool("recent_activity")
     async with get_client() as client:
         # Build common parameters for API calls
         params = {
@@ -133,7 +136,8 @@ async def recent_activity(
             params["type"] = [t.value for t in validated_types]  # pyright: ignore
 
         # Resolve project parameter using the three-tier hierarchy
-        resolved_project = await resolve_project_parameter(project)
+        # allow_discovery=True enables Discovery Mode, so a project is not required
+        resolved_project = await resolve_project_parameter(project, allow_discovery=True)
 
         if resolved_project is None:
             # Discovery Mode: Get activity across all projects
@@ -193,33 +197,7 @@ async def recent_activity(
             # Generate guidance for the assistant
             guidance_lines = ["\n" + "─" * 40]
 
-            if most_active_project and most_active_count > 0:
-                guidance_lines.extend(
-                    [
-                        f"Suggested project: '{most_active_project}' (most active with {most_active_count} items)",
-                        f"Ask user: 'Should I use {most_active_project} for this task, or would you prefer a different project?'",
-                    ]
-                )
-            elif active_projects > 0:
-                # Has activity but no clear most active project
-                active_project_names = [
-                    name for name, activity in projects_activity.items() if activity.item_count > 0
-                ]
-                if len(active_project_names) == 1:
-                    guidance_lines.extend(
-                        [
-                            f"Suggested project: '{active_project_names[0]}' (only active project)",
-                            f"Ask user: 'Should I use {active_project_names[0]} for this task?'",
-                        ]
-                    )
-                else:
-                    guidance_lines.extend(
-                        [
-                            f"Multiple active projects found: {', '.join(active_project_names)}",
-                            "Ask user: 'Which project should I use for this task?'",
-                        ]
-                    )
-            else:
+            if active_projects == 0:
                 # No recent activity
                 guidance_lines.extend(
                     [
@@ -227,6 +205,23 @@ async def recent_activity(
                         "Consider: Ask which project to use or if they want to create a new one.",
                     ]
                 )
+            else:
+                # At least one project has activity: suggest the most active project.
+                suggested_project = most_active_project or next(
+                    (name for name, activity in projects_activity.items() if activity.item_count > 0),
+                    None,
+                )
+                if suggested_project:
+                    suffix = (
+                        f"(most active with {most_active_count} items)" if most_active_count > 0 else ""
+                    )
+                    guidance_lines.append(f"Suggested project: '{suggested_project}' {suffix}".strip())
+                    if active_projects == 1:
+                        guidance_lines.append(f"Ask user: 'Should I use {suggested_project} for this task?'")
+                    else:
+                        guidance_lines.append(
+                            f"Ask user: 'Should I use {suggested_project} for this task, or would you prefer a different project?'"
+                        )
 
             guidance_lines.extend(
                 [
@@ -247,11 +242,10 @@ async def recent_activity(
             )
 
             active_project = await get_active_project(client, resolved_project, context)
-            project_url = active_project.project_url
 
             response = await call_get(
                 client,
-                f"{project_url}/memory/recent",
+                f"/v2/projects/{active_project.external_id}/memory/recent",
                 params=params,
             )
             activity_data = GraphContext.model_validate(response.json())
@@ -274,10 +268,9 @@ async def _get_project_activity(
     Returns:
         ProjectActivity with activity data or empty activity on error
     """
-    project_url = f"/{project_info.permalink}"
     activity_response = await call_get(
         client,
-        f"{project_url}/memory/recent",
+        f"/v2/projects/{project_info.external_id}/memory/recent",
         params=params,
     )
     activity = GraphContext.model_validate(activity_response.json())
@@ -289,12 +282,13 @@ async def _get_project_activity(
     for result in activity.results:
         if result.primary_result.created_at:
             current_time = result.primary_result.created_at
-            try:
-                if last_activity is None or current_time > last_activity:
-                    last_activity = current_time
-            except TypeError:
-                # Handle timezone comparison issues by skipping this comparison
-                if last_activity is None:
+            if current_time.tzinfo is None:
+                current_time = current_time.replace(tzinfo=timezone.utc)
+
+            if last_activity is None:
+                last_activity = current_time
+            else:
+                if current_time > last_activity:
                     last_activity = current_time
 
         # Extract folder from file_path

basic_memory/mcp/tools/search.py

@@ -9,7 +9,7 @@ from fastmcp import Context
 from basic_memory.mcp.async_client import get_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.telemetry import track_mcp_tool
 from basic_memory.schemas.search import SearchItemType, SearchQuery, SearchResponse
 
 
@@ -205,8 +205,8 @@ async def search_notes(
     page: int = 1,
     page_size: int = 10,
     search_type: str = "text",
-    types: List[str] = [],
-    entity_types: List[str] = [],
+    types: List[str] | None = None,
+    entity_types: List[str] | None = None,
     after_date: Optional[str] = None,
     context: Context | None = None,
 ) -> SearchResponse | str:
@@ -330,6 +330,11 @@ async def search_notes(
         # Explicit project specification
         results = await search_notes("project planning", project="my-project")
     """
+    track_mcp_tool("search_notes")
+    # Avoid mutable-default-argument footguns. Treat None as "no filter".
+    types = types or []
+    entity_types = entity_types or []
+
     # Create a SearchQuery object based on the parameters
     search_query = SearchQuery()
 
@@ -355,18 +360,20 @@ async def search_notes(
 
     async with get_client() as client:
         active_project = await get_active_project(client, project, context)
-        project_url = active_project.project_url
 
         logger.info(f"Searching for {search_query} in project {active_project.name}")
 
         try:
-            response = await call_post(
-                client,
-                f"{project_url}/search/",
-                json=search_query.model_dump(),
-                params={"page": page, "page_size": page_size},
+            # Import here to avoid circular import (tools → clients → utils → tools)
+            from basic_memory.mcp.clients import SearchClient
+
+            # Use typed SearchClient for API calls
+            search_client = SearchClient(client, active_project.external_id)
+            result = await search_client.search(
+                search_query.model_dump(),
+                page=page,
+                page_size=page_size,
             )
-            result = SearchResponse.model_validate(response.json())
 
             # Check if we got no results and provide helpful guidance
             if not result.results:

basic_memory/mcp/tools/utils.py

@@ -435,6 +435,34 @@ async def call_post(
         raise ToolError(error_message) from e
 
 
+async def resolve_entity_id(client: AsyncClient, project_external_id: str, identifier: str) -> str:
+    """Resolve a string identifier to an entity external_id using the v2 API.
+
+    Args:
+        client: HTTP client for API calls
+        project_external_id: Project external ID (UUID)
+        identifier: The identifier to resolve (permalink, title, or path)
+
+    Returns:
+        The resolved entity external_id (UUID)
+
+    Raises:
+        ToolError: If the identifier cannot be resolved
+    """
+    try:
+        response = await call_post(
+            client, f"/v2/projects/{project_external_id}/knowledge/resolve", json={"identifier": identifier}
+        )
+        data = response.json()
+        return data["external_id"]
+    except HTTPStatusError as e:
+        if e.response.status_code == 404:  # pragma: no cover
+            raise ToolError(f"Entity not found: '{identifier}'")  # pragma: no cover
+        raise ToolError(f"Error resolving identifier '{identifier}': {e}")  # pragma: no cover
+    except Exception as e:
+        raise ToolError(f"Unexpected error resolving identifier '{identifier}': {e}")  # pragma: no cover
+
+
 async def call_delete(
     client: AsyncClient,
     url: URL | str,

basic_memory/mcp/tools/view_note.py

@@ -8,6 +8,7 @@ from fastmcp import Context
 
 from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.read_note import read_note
+from basic_memory.telemetry import track_mcp_tool
 
 
 @mcp.tool(
@@ -54,7 +55,7 @@ async def view_note(
         HTTPError: If project doesn't exist or is inaccessible
         SecurityError: If identifier attempts path traversal
     """
-
+    track_mcp_tool("view_note")
     logger.info(f"Viewing note: {identifier} in project: {project}")
 
     # Call the existing read_note logic

basic_memory/mcp/tools/write_note.py

@@ -7,8 +7,7 @@ from loguru import logger
 from basic_memory.mcp.async_client import get_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.schemas import EntityResponse
+from basic_memory.telemetry import track_mcp_tool
 from fastmcp import Context
 from basic_memory.schemas.base import Entity
 from basic_memory.utils import parse_tags, validate_project_path
@@ -116,6 +115,7 @@ async def write_note(
         HTTPError: If project doesn't exist or is inaccessible
         SecurityError: If folder path attempts path traversal
     """
+    track_mcp_tool("write_note")
     async with get_client() as client:
         logger.info(
             f"MCP tool call tool=write_note project={project} folder={folder}, title={title}, tags={tags}"
@@ -150,16 +150,39 @@ async def write_note(
             content=content,
             entity_metadata=metadata,
         )
-        project_url = active_project.permalink
 
-        # Create or update via knowledge API
-        logger.debug(f"Creating entity via API permalink={entity.permalink}")
-        url = f"{project_url}/knowledge/entities/{entity.permalink}"
-        response = await call_put(client, url, json=entity.model_dump())
-        result = EntityResponse.model_validate(response.json())
-
-        # Format semantic summary based on status code
-        action = "Created" if response.status_code == 201 else "Updated"
+        # Import here to avoid circular import
+        from basic_memory.mcp.clients import KnowledgeClient
+
+        # Use typed KnowledgeClient for API calls
+        knowledge_client = KnowledgeClient(client, active_project.external_id)
+
+        # Try to create the entity first (optimistic create)
+        logger.debug(f"Attempting to create entity permalink={entity.permalink}")
+        action = "Created"  # Default to created
+        try:
+            result = await knowledge_client.create_entity(entity.model_dump())
+            action = "Created"
+        except Exception as e:
+            # If creation failed due to conflict (already exists), try to update
+            if (
+                "409" in str(e)
+                or "conflict" in str(e).lower()
+                or "already exists" in str(e).lower()
+            ):
+                logger.debug(f"Entity exists, updating instead permalink={entity.permalink}")
+                try:
+                    if not entity.permalink:
+                        raise ValueError("Entity permalink is required for updates")  # pragma: no cover
+                    entity_id = await knowledge_client.resolve_entity(entity.permalink)
+                    result = await knowledge_client.update_entity(entity_id, entity.model_dump())
+                    action = "Updated"
+                except Exception as update_error:  # pragma: no cover
+                    # Re-raise the original error if update also fails
+                    raise e from update_error  # pragma: no cover
+            else:
+                # Re-raise if it's not a conflict error
+                raise  # pragma: no cover
         summary = [
             f"# {action} note",
             f"project: {active_project.name}",
@@ -201,7 +224,7 @@ async def write_note(
 
         # Log the response with structured data
         logger.info(
-            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}"
+            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}"
         )
-        result = "\n".join(summary)
-        return add_project_metadata(result, active_project.name)
+        summary_result = "\n".join(summary)
+        return add_project_metadata(summary_result, active_project.name)

basic_memory/models/knowledge.py

@@ -1,5 +1,6 @@
 """Knowledge graph models."""
 
+import uuid
 from datetime import datetime
 from basic_memory.utils import ensure_timezone_aware
 from typing import Optional
@@ -38,6 +39,7 @@ class Entity(Base):
         # Regular indexes
         Index("ix_entity_type", "entity_type"),
         Index("ix_entity_title", "title"),
+        Index("ix_entity_external_id", "external_id", unique=True),
         Index("ix_entity_created_at", "created_at"),  # For timeline queries
         Index("ix_entity_updated_at", "updated_at"),  # For timeline queries
         Index("ix_entity_project_id", "project_id"),  # For project filtering
@@ -59,6 +61,10 @@ class Entity(Base):
 
     # Core identity
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    # External UUID for API references - stable identifier that won't change
+    external_id: Mapped[str] = mapped_column(
+        String, unique=True, default=lambda: str(uuid.uuid4())
+    )
     title: Mapped[str] = mapped_column(String)
     entity_type: Mapped[str] = mapped_column(String)
     entity_metadata: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True)
@@ -129,7 +135,7 @@ class Entity(Base):
         return value
 
     def __repr__(self) -> str:
-        return f"Entity(id={self.id}, name='{self.title}', type='{self.entity_type}'"
+        return f"Entity(id={self.id}, external_id='{self.external_id}', name='{self.title}', type='{self.entity_type}', checksum='{self.checksum}')"
 
 
 class Observation(Base):
@@ -145,6 +151,7 @@ class Observation(Base):
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    project_id: Mapped[int] = mapped_column(Integer, ForeignKey("project.id"), index=True)
     entity_id: Mapped[int] = mapped_column(Integer, ForeignKey("entity.id", ondelete="CASCADE"))
     content: Mapped[str] = mapped_column(Text)
     category: Mapped[str] = mapped_column(String, nullable=False, default="note")
@@ -162,9 +169,14 @@ class Observation(Base):
 
         We can construct these because observations are always defined in
         and owned by a single entity.
+
+        Content is truncated to 200 chars to stay under PostgreSQL's
+        btree index limit of 2704 bytes.
         """
+        # Truncate content to avoid exceeding PostgreSQL's btree index limit
+        content_for_permalink = self.content[:200] if len(self.content) > 200 else self.content
         return generate_permalink(
-            f"{self.entity.permalink}/observations/{self.category}/{self.content}"
+            f"{self.entity.permalink}/observations/{self.category}/{content_for_permalink}"
         )
 
     def __repr__(self) -> str:  # pragma: no cover
@@ -186,6 +198,7 @@ class Relation(Base):
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    project_id: Mapped[int] = mapped_column(Integer, ForeignKey("project.id"), index=True)
     from_id: Mapped[int] = mapped_column(Integer, ForeignKey("entity.id", ondelete="CASCADE"))
     to_id: Mapped[Optional[int]] = mapped_column(
         Integer, ForeignKey("entity.id", ondelete="CASCADE"), nullable=True

basic_memory/models/project.py

@@ -1,5 +1,6 @@
 """Project model for Basic Memory."""
 
+import uuid
 from datetime import datetime, UTC
 from typing import Optional
 
@@ -32,6 +33,7 @@ class Project(Base):
         # Regular indexes
         Index("ix_project_name", "name", unique=True),
         Index("ix_project_permalink", "permalink", unique=True),
+        Index("ix_project_external_id", "external_id", unique=True),
         Index("ix_project_path", "path"),
         Index("ix_project_created_at", "created_at"),
         Index("ix_project_updated_at", "updated_at"),
@@ -39,6 +41,10 @@ class Project(Base):
 
     # Core identity
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    # External UUID for API references - stable identifier that won't change
+    external_id: Mapped[str] = mapped_column(
+        String, unique=True, default=lambda: str(uuid.uuid4())
+    )
     name: Mapped[str] = mapped_column(String, unique=True)
     description: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
 
@@ -71,7 +77,7 @@ class Project(Base):
     entities = relationship("Entity", back_populates="project", cascade="all, delete-orphan")
 
     def __repr__(self) -> str:  # pragma: no cover
-        return f"Project(id={self.id}, name='{self.name}', permalink='{self.permalink}', path='{self.path}')"
+        return f"Project(id={self.id}, external_id='{self.external_id}', name='{self.name}', permalink='{self.permalink}', path='{self.path}')"
 
 
 @event.listens_for(Project, "before_insert")

basic_memory/models/search.py

@@ -1,8 +1,64 @@
-"""Search models and tables."""
+"""Search DDL statements for SQLite and Postgres.
+
+The search_index table is created via raw DDL, not ORM models, because:
+- SQLite uses FTS5 virtual tables (cannot be represented as ORM)
+- Postgres uses composite primary keys and generated tsvector columns
+- Both backends use raw SQL for all search operations via SearchIndexRow dataclass
+"""
 
 from sqlalchemy import DDL
 
-# Define FTS5 virtual table creation
+
+# Define Postgres search_index table with composite primary key and tsvector
+# This DDL matches the Alembic migration schema (314f1ea54dc4)
+# Used by tests to create the table without running full migrations
+# NOTE: Split into separate DDL statements because asyncpg doesn't support
+# multiple statements in a single execute call.
+CREATE_POSTGRES_SEARCH_INDEX_TABLE = DDL("""
+CREATE TABLE IF NOT EXISTS search_index (
+    id INTEGER NOT NULL,
+    project_id INTEGER NOT NULL,
+    title TEXT,
+    content_stems TEXT,
+    content_snippet TEXT,
+    permalink VARCHAR,
+    file_path VARCHAR,
+    type VARCHAR,
+    from_id INTEGER,
+    to_id INTEGER,
+    relation_type VARCHAR,
+    entity_id INTEGER,
+    category VARCHAR,
+    metadata JSONB,
+    created_at TIMESTAMP WITH TIME ZONE,
+    updated_at TIMESTAMP WITH TIME ZONE,
+    textsearchable_index_col tsvector GENERATED ALWAYS AS (
+        to_tsvector('english', coalesce(title, '') || ' ' || coalesce(content_stems, ''))
+    ) STORED,
+    PRIMARY KEY (id, type, project_id),
+    FOREIGN KEY (project_id) REFERENCES project(id) ON DELETE CASCADE
+)
+""")
+
+CREATE_POSTGRES_SEARCH_INDEX_FTS = DDL("""
+CREATE INDEX IF NOT EXISTS idx_search_index_fts ON search_index USING gin(textsearchable_index_col)
+""")
+
+CREATE_POSTGRES_SEARCH_INDEX_METADATA = DDL("""
+CREATE INDEX IF NOT EXISTS idx_search_index_metadata_gin ON search_index USING gin(metadata jsonb_path_ops)
+""")
+
+# Partial unique index on (permalink, project_id) for non-null permalinks
+# This prevents duplicate permalinks per project and is used by upsert operations
+# in PostgresSearchRepository to handle race conditions during parallel indexing
+CREATE_POSTGRES_SEARCH_INDEX_PERMALINK = DDL("""
+CREATE UNIQUE INDEX IF NOT EXISTS uix_search_index_permalink_project
+ON search_index (permalink, project_id)
+WHERE permalink IS NOT NULL
+""")
+
+# Define FTS5 virtual table creation for SQLite only
+# This DDL is executed separately for SQLite databases
 CREATE_SEARCH_INDEX = DDL("""
 CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(
     -- Core entity fields