memu-py 1.1.2__cp313-abi3-win_amd64.whl → 1.3.0__cp313-abi3-win_amd64.whl

memu/app/crud.py

@@ -76,6 +76,27 @@ class CRUDMixin:
             raise RuntimeError(msg)
         return response
 
+    async def clear_memory(
+        self,
+        where: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        ctx = self._get_context()
+        store = self._get_database()
+        where_filters = self._normalize_where(where)
+
+        state: WorkflowState = {
+            "ctx": ctx,
+            "store": store,
+            "where": where_filters,
+        }
+
+        result = await self._run_workflow("crud_clear_memory", state)
+        response = cast(dict[str, Any] | None, result.get("response"))
+        if response is None:
+            msg = "Clear memory workflow failed to produce a response"
+            raise RuntimeError(msg)
+        return response
+
     def _build_list_memory_items_workflow(self) -> list[WorkflowStep]:
         steps = [
             WorkflowStep(
@@ -98,7 +119,7 @@ class CRUDMixin:
         return steps
 
     @staticmethod
-    def _list_list_memory_items_initial_keys() -> set[str]:
+    def _list_list_memories_initial_keys() -> set[str]:
         return {
             "ctx",
             "store",
@@ -126,6 +147,51 @@ class CRUDMixin:
         ]
         return steps
 
+    def _build_clear_memory_workflow(self) -> list[WorkflowStep]:
+        steps = [
+            WorkflowStep(
+                step_id="clear_memory_categories",
+                role="delete_memories",
+                handler=self._crud_clear_memory_categories,
+                requires={"ctx", "store", "where"},
+                produces={"deleted_categories"},
+                capabilities={"db"},
+            ),
+            WorkflowStep(
+                step_id="clear_memory_items",
+                role="delete_memories",
+                handler=self._crud_clear_memory_items,
+                requires={"ctx", "store", "where"},
+                produces={"deleted_items"},
+                capabilities={"db"},
+            ),
+            WorkflowStep(
+                step_id="clear_memory_resources",
+                role="delete_memories",
+                handler=self._crud_clear_memory_resources,
+                requires={"ctx", "store", "where"},
+                produces={"deleted_resources"},
+                capabilities={"db"},
+            ),
+            WorkflowStep(
+                step_id="build_response",
+                role="emit",
+                handler=self._crud_build_clear_memory_response,
+                requires={"ctx", "store", "deleted_categories", "deleted_items", "deleted_resources"},
+                produces={"response"},
+                capabilities=set(),
+            ),
+        ]
+        return steps
+
+    @staticmethod
+    def _list_clear_memories_initial_keys() -> set[str]:
+        return {
+            "ctx",
+            "store",
+            "where",
+        }
+
     def _normalize_where(self, where: Mapping[str, Any] | None) -> dict[str, Any]:
         """Validate and clean the `where` scope filters against the configured user model."""
         if not where:
@@ -177,6 +243,39 @@ class CRUDMixin:
         state["response"] = response
         return state
 
+    def _crud_clear_memory_categories(self, state: WorkflowState, step_context: Any) -> WorkflowState:
+        where_filters = state.get("where") or {}
+        store = state["store"]
+        deleted = store.memory_category_repo.clear_categories(where_filters)
+        state["deleted_categories"] = deleted
+        return state
+
+    def _crud_clear_memory_items(self, state: WorkflowState, step_context: Any) -> WorkflowState:
+        where_filters = state.get("where") or {}
+        store = state["store"]
+        deleted = store.memory_item_repo.clear_items(where_filters)
+        state["deleted_items"] = deleted
+        return state
+
+    def _crud_clear_memory_resources(self, state: WorkflowState, step_context: Any) -> WorkflowState:
+        where_filters = state.get("where") or {}
+        store = state["store"]
+        deleted = store.resource_repo.clear_resources(where_filters)
+        state["deleted_resources"] = deleted
+        return state
+
+    def _crud_build_clear_memory_response(self, state: WorkflowState, step_context: Any) -> WorkflowState:
+        deleted_categories = state.get("deleted_categories", {})
+        deleted_items = state.get("deleted_items", {})
+        deleted_resources = state.get("deleted_resources", {})
+        response = {
+            "deleted_categories": [self._model_dump_without_embeddings(cat) for cat in deleted_categories.values()],
+            "deleted_items": [self._model_dump_without_embeddings(item) for item in deleted_items.values()],
+            "deleted_resources": [self._model_dump_without_embeddings(res) for res in deleted_resources.values()],
+        }
+        state["response"] = response
+        return state
+
     async def create_memory_item(
         self,
         *,

memu/app/service.py

@@ -30,6 +30,7 @@ from memu.llm.wrapper import (
     LLMInterceptorHandle,
     LLMInterceptorRegistry,
 )
+from memu.workflow.interceptor import WorkflowInterceptorHandle, WorkflowInterceptorRegistry
 from memu.workflow.pipeline import PipelineManager
 from memu.workflow.runner import WorkflowRunner, resolve_workflow_runner
 from memu.workflow.step import WorkflowState, WorkflowStep
@@ -83,6 +84,7 @@ class MemoryService(MemorizeMixin, RetrieveMixin, CRUDMixin):
         # Initialize client caches (lazy creation on first use)
         self._llm_clients: dict[str, Any] = {}
         self._llm_interceptors = LLMInterceptorRegistry()
+        self._workflow_interceptors = WorkflowInterceptorRegistry()
 
         self._workflow_runner = resolve_workflow_runner(workflow_runner)
 
@@ -115,6 +117,19 @@ class MemoryService(MemorizeMixin, RetrieveMixin, CRUDMixin):
                 endpoint_overrides=cfg.endpoint_overrides,
                 embed_model=cfg.embed_model,
             )
+        elif backend == "lazyllm_backend":
+            from memu.llm.lazyllm_client import LazyLLMClient
+
+            return LazyLLMClient(
+                llm_source=cfg.lazyllm_source.llm_source or cfg.lazyllm_source.source,
+                vlm_source=cfg.lazyllm_source.vlm_source or cfg.lazyllm_source.source,
+                embed_source=cfg.lazyllm_source.embed_source or cfg.lazyllm_source.source,
+                stt_source=cfg.lazyllm_source.stt_source or cfg.lazyllm_source.source,
+                chat_model=cfg.chat_model,
+                embed_model=cfg.embed_model,
+                vlm_model=cfg.lazyllm_source.vlm_model,
+                stt_model=cfg.lazyllm_source.stt_model,
+            )
         else:
             msg = f"Unknown llm_client_backend '{cfg.client_backend}'"
             raise ValueError(msg)
@@ -240,6 +255,45 @@ class MemoryService(MemorizeMixin, RetrieveMixin, CRUDMixin):
     ) -> LLMInterceptorHandle:
         return self._llm_interceptors.register_on_error(fn, name=name, priority=priority, where=where)
 
+    def intercept_before_workflow_step(
+        self,
+        fn: Callable[..., Any],
+        *,
+        name: str | None = None,
+    ) -> WorkflowInterceptorHandle:
+        """
+        Register an interceptor to be called before each workflow step.
+
+        The interceptor receives (step_context: WorkflowStepContext, state: WorkflowState).
+        """
+        return self._workflow_interceptors.register_before(fn, name=name)
+
+    def intercept_after_workflow_step(
+        self,
+        fn: Callable[..., Any],
+        *,
+        name: str | None = None,
+    ) -> WorkflowInterceptorHandle:
+        """
+        Register an interceptor to be called after each workflow step.
+
+        The interceptor receives (step_context: WorkflowStepContext, state: WorkflowState).
+        """
+        return self._workflow_interceptors.register_after(fn, name=name)
+
+    def intercept_on_error_workflow_step(
+        self,
+        fn: Callable[..., Any],
+        *,
+        name: str | None = None,
+    ) -> WorkflowInterceptorHandle:
+        """
+        Register an interceptor to be called when a workflow step raises an exception.
+
+        The interceptor receives (step_context: WorkflowStepContext, state: WorkflowState, error: Exception).
+        """
+        return self._workflow_interceptors.register_on_error(fn, name=name)
+
     def _get_context(self) -> Context:
         return self._context
 
@@ -277,7 +331,7 @@ class MemoryService(MemorizeMixin, RetrieveMixin, CRUDMixin):
         patch_delete_initial_keys = CRUDMixin._list_delete_memory_item_initial_keys()
         self._pipelines.register("patch_delete", patch_delete_workflow, initial_state_keys=patch_delete_initial_keys)
         crud_list_items_workflow = self._build_list_memory_items_workflow()
-        crud_list_memories_initial_keys = CRUDMixin._list_list_memory_items_initial_keys()
+        crud_list_memories_initial_keys = CRUDMixin._list_list_memories_initial_keys()
         self._pipelines.register(
             "crud_list_memory_items", crud_list_items_workflow, initial_state_keys=crud_list_memories_initial_keys
         )
@@ -287,12 +341,23 @@ class MemoryService(MemorizeMixin, RetrieveMixin, CRUDMixin):
             crud_list_categories_workflow,
             initial_state_keys=crud_list_memories_initial_keys,
         )
+        crud_clear_memory_workflow = self._build_clear_memory_workflow()
+        crud_clear_memory_initial_keys = CRUDMixin._list_clear_memories_initial_keys()
+        self._pipelines.register(
+            "crud_clear_memory", crud_clear_memory_workflow, initial_state_keys=crud_clear_memory_initial_keys
+        )
 
     async def _run_workflow(self, workflow_name: str, initial_state: WorkflowState) -> WorkflowState:
         """Execute a workflow through the configured runner backend."""
         steps = self._pipelines.build(workflow_name)
         runner_context = {"workflow_name": workflow_name}
-        return await self._workflow_runner.run(workflow_name, steps, initial_state, runner_context)
+        return await self._workflow_runner.run(
+            workflow_name,
+            steps,
+            initial_state,
+            runner_context,
+            interceptor_registry=self._workflow_interceptors,
+        )
 
     @staticmethod
     def _extract_json_blob(raw: str) -> str:

memu/app/settings.py

@@ -36,7 +36,7 @@ def _default_memory_type_prompts() -> "dict[str, str | CustomPrompt]":
 
 
 class PromptBlock(BaseModel):
-    lable: str | None = None
+    label: str | None = None
     ordinal: int = Field(default=0)
     prompt: str | None = None
 
@@ -89,6 +89,16 @@ def _default_memory_categories() -> list[CategoryConfig]:
     ]
 
 
+class LazyLLMSource(BaseModel):
+    source: str | None = Field(default=None, description="default source for lazyllm client backend")
+    llm_source: str | None = Field(default=None, description="LLM source for lazyllm client backend")
+    embed_source: str | None = Field(default=None, description="Embedding source for lazyllm client backend")
+    vlm_source: str | None = Field(default=None, description="VLM source for lazyllm client backend")
+    stt_source: str | None = Field(default=None, description="STT source for lazyllm client backend")
+    vlm_model: str = Field(default="qwen-vl-plus", description="Vision language model for lazyllm client backend")
+    stt_model: str = Field(default="qwen-audio-turbo", description="Speech-to-text model for lazyllm client backend")
+
+
 class LLMConfig(BaseModel):
     provider: str = Field(
         default="openai",
@@ -99,8 +109,9 @@ class LLMConfig(BaseModel):
     chat_model: str = Field(default="gpt-4o-mini")
     client_backend: str = Field(
         default="sdk",
-        description="Which LLM client backend to use: 'httpx' (httpx) or 'sdk' (official OpenAI).",
+        description="Which LLM client backend to use: 'httpx' (httpx), 'sdk' (official OpenAI), or 'lazyllm_backend' (for more LLM source like Qwen, Doubao, SIliconflow, etc.)",
     )
+    lazyllm_source: LazyLLMSource = Field(default=LazyLLMSource())
     endpoint_overrides: dict[str, str] = Field(
         default_factory=dict,
         description="Optional overrides for HTTP endpoints (keys: 'chat'/'summary').",
@@ -110,10 +121,22 @@ class LLMConfig(BaseModel):
         description="Default embedding model used for vectorization.",
     )
     embed_batch_size: int = Field(
-        default=25,
+        default=1,
         description="Maximum batch size for embedding API calls (used by SDK client backends).",
     )
 
+    @model_validator(mode="after")
+    def set_provider_defaults(self) -> "LLMConfig":
+        if self.provider == "grok":
+            # If values match the OpenAI defaults, switch them to Grok defaults
+            if self.base_url == "https://api.openai.com/v1":
+                self.base_url = "https://api.x.ai/v1"
+            if self.api_key == "OPENAI_API_KEY":
+                self.api_key = "XAI_API_KEY"
+            if self.chat_model == "gpt-4o-mini":
+                self.chat_model = "grok-2-latest"
+        return self
+
 
 class BlobConfig(BaseModel):
     provider: str = Field(default="local")
@@ -248,9 +271,9 @@ class LLMProfilesConfig(RootModel[dict[Key, LLMConfig]]):
 
 
 class MetadataStoreConfig(BaseModel):
-    provider: Annotated[Literal["inmemory", "postgres"], Normalize] = "inmemory"
+    provider: Annotated[Literal["inmemory", "postgres", "sqlite"], Normalize] = "inmemory"
     ddl_mode: Annotated[Literal["create", "validate"], Normalize] = "create"
-    dsn: str | None = Field(default=None, description="Postgres connection string when provider=postgres.")
+    dsn: str | None = Field(default=None, description="Database connection string (required for postgres/sqlite).")
 
 
 class VectorIndexConfig(BaseModel):

memu/database/__init__.py

@@ -24,4 +24,5 @@ __all__ = [
     "inmemory",
     "postgres",
     "schema",
+    "sqlite",
 ]

memu/database/factory.py

@@ -19,6 +19,11 @@ def build_database(
 ) -> Database:
     """
     Initialize a database backend for the configured provider.
+
+    Supported providers:
+        - "inmemory": In-memory storage (default, no persistence)
+        - "postgres": PostgreSQL with optional pgvector support
+        - "sqlite": SQLite file-based storage (lightweight, portable)
     """
     provider = config.metadata_store.provider
     if provider == "inmemory":
@@ -28,6 +33,11 @@ def build_database(
         from memu.database.postgres import build_postgres_database
 
         return build_postgres_database(config=config, user_model=user_model)
+    elif provider == "sqlite":
+        # Lazy import to avoid loading SQLite dependencies when not needed
+        from memu.database.sqlite import build_sqlite_database
+
+        return build_sqlite_database(config=config, user_model=user_model)
     else:
         msg = f"Unsupported metadata_store provider: {provider}"
         raise ValueError(msg)

memu/database/inmemory/repositories/memory_category_repo.py

@@ -23,6 +23,15 @@ class InMemoryMemoryCategoryRepository(MemoryCategoryRepoProtocol):
             return dict(self.categories)
         return {cid: cat for cid, cat in self.categories.items() if matches_where(cat, where)}
 
+    def clear_categories(self, where: Mapping[str, Any] | None = None) -> dict[str, MemoryCategory]:
+        if not where:
+            matches = self.categories.copy()
+            self.categories.clear()
+            return matches
+        matches = {cid: cat for cid, cat in self.categories.items() if matches_where(cat, where)}
+        self.categories = {cid: cat for cid, cat in self.categories.items() if cid not in matches}
+        return matches
+
     def get_or_create_category(
         self, *, name: str, description: str, embedding: list[float], user_data: dict[str, Any]
     ) -> MemoryCategory:

memu/database/inmemory/repositories/memory_item_repo.py

@@ -22,6 +22,15 @@ class InMemoryMemoryItemRepository(MemoryItemRepo):
             return dict(self.items)
         return {mid: item for mid, item in self.items.items() if matches_where(item, where)}
 
+    def clear_items(self, where: Mapping[str, Any] | None = None) -> dict[str, MemoryItem]:
+        if not where:
+            matches = self.items.copy()
+            self.items.clear()
+            return matches
+        matches = {mid: item for mid, item in self.items.items() if matches_where(item, where)}
+        self.items = {mid: item for mid, item in self.items.items() if mid not in matches}
+        return matches
+
     def create_item(
         self,
         *,

memu/database/inmemory/repositories/resource_repo.py

@@ -21,6 +21,15 @@ class InMemoryResourceRepository(ResourceRepoProtocol):
             return dict(self.resources)
         return {rid: res for rid, res in self.resources.items() if matches_where(res, where)}
 
+    def clear_resources(self, where: Mapping[str, Any] | None = None) -> dict[str, Resource]:
+        if not where:
+            matches = self.resources.copy()
+            self.resources.clear()
+            return matches
+        matches = {rid: res for rid, res in self.resources.items() if matches_where(res, where)}
+        self.resources = {rid: res for rid, res in self.resources.items() if rid not in matches}
+        return matches
+
     def create_resource(
         self,
         *,

memu/database/inmemory/vector.py

@@ -16,16 +16,37 @@ def cosine_topk(
     corpus: Iterable[tuple[str, list[float] | None]],
     k: int = 5,
 ) -> list[tuple[str, float]]:
-    q = np.array(query_vec, dtype=np.float32)
-    scored: list[tuple[str, float]] = []
+    # Filter out None vectors and collect valid entries
+    ids: list[str] = []
+    vecs: list[list[float]] = []
     for _id, vec in corpus:
-        if vec is None:
-            continue
-        vec_list = cast(list[float], vec)
-        v = np.array(vec_list, dtype=np.float32)
-        scored.append((_id, _cosine(q, v)))
-    scored.sort(key=lambda x: x[1], reverse=True)
-    return scored[:k]
+        if vec is not None:
+            ids.append(_id)
+            vecs.append(cast(list[float], vec))
+
+    if not vecs:
+        return []
+
+    # Vectorized computation: stack all vectors into a matrix
+    q = np.array(query_vec, dtype=np.float32)
+    matrix = np.array(vecs, dtype=np.float32)  # shape: (n, dim)
+
+    # Compute all cosine similarities at once
+    q_norm = np.linalg.norm(q)
+    vec_norms = np.linalg.norm(matrix, axis=1)
+    scores = matrix @ q / (vec_norms * q_norm + 1e-9)
+
+    # Use argpartition for O(n) topk selection instead of O(n log n) sort
+    n = len(scores)
+    actual_k = min(k, n)
+    if actual_k == n:
+        topk_indices = np.argsort(scores)[::-1]
+    else:
+        # Get indices of top k elements (unordered), then sort only those
+        topk_indices = np.argpartition(scores, -actual_k)[-actual_k:]
+        topk_indices = topk_indices[np.argsort(scores[topk_indices])[::-1]]
+
+    return [(ids[i], float(scores[i])) for i in topk_indices]
 
 
 def query_cosine(query_vec: list[float], vecs: list[list[float]]) -> list[tuple[int, float]]:

memu/database/models.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import uuid
 from datetime import datetime
-from typing import Literal
+from typing import Any, Literal
 
 import pendulum
 from pydantic import BaseModel, ConfigDict, Field
@@ -28,9 +28,11 @@ class Resource(BaseRecord):
 
 class MemoryItem(BaseRecord):
     resource_id: str | None
-    memory_type: MemoryType
+    memory_type: str
     summary: str
     embedding: list[float] | None = None
+    happened_at: datetime | None = None
+    extra: dict[str, Any] = {}
 
 
 class MemoryCategory(BaseRecord):

memu/database/postgres/models.py

@@ -14,6 +14,7 @@ except ImportError as exc:
 
 from pydantic import BaseModel
 from sqlalchemy import ForeignKey, MetaData, String, Text
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlmodel import Column, DateTime, Field, Index, SQLModel, func
 
 from memu.database.models import CategoryItem, MemoryCategory, MemoryItem, MemoryType, Resource
@@ -51,10 +52,12 @@ class ResourceModel(BaseModelMixin, Resource):
 
 
 class MemoryItemModel(BaseModelMixin, MemoryItem):
-    resource_id: str = Field(sa_column=Column(ForeignKey("resources.id", ondelete="CASCADE"), nullable=True))
+    resource_id: str | None = Field(sa_column=Column(ForeignKey("resources.id", ondelete="CASCADE"), nullable=True))
     memory_type: MemoryType = Field(sa_column=Column(String, nullable=False))
     summary: str = Field(sa_column=Column(Text, nullable=False))
     embedding: list[float] | None = Field(default=None, sa_column=Column(Vector(), nullable=True))
+    happened_at: datetime | None = Field(default=None, sa_column=Column(DateTime, nullable=True))
+    extra: dict[str, Any] = Field(default={}, sa_column=Column(JSONB, nullable=True))
 
 
 class MemoryCategoryModel(BaseModelMixin, MemoryCategory):

memu/database/postgres/repositories/memory_category_repo.py

@@ -37,6 +37,31 @@ class PostgresMemoryCategoryRepo(PostgresRepoBase, MemoryCategoryRepo):
                 result[cat.id] = cat
         return result
 
+    def clear_categories(self, where: Mapping[str, Any] | None = None) -> dict[str, MemoryCategory]:
+        from sqlmodel import delete, select
+
+        filters = self._build_filters(self._sqla_models.MemoryCategory, where)
+        with self._sessions.session() as session:
+            # First get the objects to delete
+            rows = session.scalars(select(self._sqla_models.MemoryCategory).where(*filters)).all()
+            deleted: dict[str, MemoryCategory] = {}
+            for row in rows:
+                row.embedding = self._normalize_embedding(row.embedding)
+                deleted[row.id] = row
+
+            if not deleted:
+                return {}
+
+            # Delete from database
+            session.exec(delete(self._sqla_models.MemoryCategory).where(*filters))
+            session.commit()
+
+            # Clean up cache
+            for cat_id in deleted:
+                self.categories.pop(cat_id, None)
+
+        return deleted
+
     def get_or_create_category(
         self,
         *,

memu/database/postgres/repositories/memory_item_repo.py

@@ -51,6 +51,31 @@ class PostgresMemoryItemRepo(PostgresRepoBase):
                 result[item.id] = item
         return result
 
+    def clear_items(self, where: Mapping[str, Any] | None = None) -> dict[str, MemoryItem]:
+        from sqlmodel import delete, select
+
+        filters = self._build_filters(self._sqla_models.MemoryItem, where)
+        with self._sessions.session() as session:
+            # First get the objects to delete
+            rows = session.scalars(select(self._sqla_models.MemoryItem).where(*filters)).all()
+            deleted: dict[str, MemoryItem] = {}
+            for row in rows:
+                row.embedding = self._normalize_embedding(row.embedding)
+                deleted[row.id] = row
+
+            if not deleted:
+                return {}
+
+            # Delete from database
+            session.exec(delete(self._sqla_models.MemoryItem).where(*filters))
+            session.commit()
+
+            # Clean up cache
+            for item_id in deleted:
+                self.items.pop(item_id, None)
+
+        return deleted
+
     def create_item(
         self,
         *,

memu/database/postgres/repositories/resource_repo.py

@@ -37,6 +37,31 @@ class PostgresResourceRepo(PostgresRepoBase, ResourceRepo):
                 result[res.id] = res
         return result
 
+    def clear_resources(self, where: Mapping[str, Any] | None = None) -> dict[str, Resource]:
+        from sqlmodel import delete, select
+
+        filters = self._build_filters(self._sqla_models.Resource, where)
+        with self._sessions.session() as session:
+            # First get the objects to delete
+            rows = session.scalars(select(self._sqla_models.Resource).where(*filters)).all()
+            deleted: dict[str, Resource] = {}
+            for row in rows:
+                row.embedding = self._normalize_embedding(row.embedding)
+                deleted[row.id] = row
+
+            if not deleted:
+                return {}
+
+            # Delete from database
+            session.exec(delete(self._sqla_models.Resource).where(*filters))
+            session.commit()
+
+            # Clean up cache
+            for res_id in deleted:
+                self.resources.pop(res_id, None)
+
+        return deleted
+
     def create_resource(
         self,
         *,

memu/database/repositories/memory_category.py

@@ -14,6 +14,8 @@ class MemoryCategoryRepo(Protocol):
 
     def list_categories(self, where: Mapping[str, Any] | None = None) -> dict[str, MemoryCategory]: ...
 
+    def clear_categories(self, where: Mapping[str, Any] | None = None) -> dict[str, MemoryCategory]: ...
+
     def get_or_create_category(
         self, *, name: str, description: str, embedding: list[float], user_data: dict[str, Any]
     ) -> MemoryCategory: ...

memu/database/repositories/memory_item.py

@@ -16,6 +16,8 @@ class MemoryItemRepo(Protocol):
 
     def list_items(self, where: Mapping[str, Any] | None = None) -> dict[str, MemoryItem]: ...
 
+    def clear_items(self, where: Mapping[str, Any] | None = None) -> dict[str, MemoryItem]: ...
+
     def create_item(
         self,
         *,

memu/database/repositories/resource.py

@@ -14,6 +14,8 @@ class ResourceRepo(Protocol):
 
     def list_resources(self, where: Mapping[str, Any] | None = None) -> dict[str, Resource]: ...
 
+    def clear_resources(self, where: Mapping[str, Any] | None = None) -> dict[str, Resource]: ...
+
     def create_resource(
         self,
         *,

memu/database/sqlite/__init__.py

@@ -0,0 +1,36 @@
+"""SQLite database backend for MemU."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from memu.app.settings import DatabaseConfig
+from memu.database.sqlite.sqlite import SQLiteStore
+
+
+def build_sqlite_database(
+    *,
+    config: DatabaseConfig,
+    user_model: type[BaseModel],
+) -> SQLiteStore:
+    """Build a SQLite database store instance.
+
+    Args:
+        config: Database configuration containing metadata_store settings.
+        user_model: Pydantic model for user scope fields.
+
+    Returns:
+        Configured SQLiteStore instance.
+    """
+    dsn = config.metadata_store.dsn
+    if not dsn:
+        # Default to a local file if no DSN provided
+        dsn = "sqlite:///memu.db"
+
+    return SQLiteStore(
+        dsn=dsn,
+        scope_model=user_model,
+    )
+
+
+__all__ = ["SQLiteStore", "build_sqlite_database"]