mdb-engine 0.7.3__py3-none-any.whl → 0.7.4__py3-none-any.whl

mdb_engine/__init__.py

@@ -81,7 +81,7 @@ from .repositories import Entity, MongoRepository, Repository, UnitOfWork
 # Utilities
 from .utils import clean_mongo_doc, clean_mongo_docs
 
-__version__ = "0.7.3"
+__version__ = "0.7.4"
 
 __all__ = [
     # Core Engine

mdb_engine/cli/main.py

@@ -15,7 +15,7 @@ from .commands.validate import validate
 
 
 @click.group()
-@click.version_option(version="0.7.3", prog_name="mdb")
+@click.version_option(version="0.7.4", prog_name="mdb")
 def cli() -> None:
     """
     MDB_ENGINE CLI - Manifest management tool.

mdb_engine/core/engine.py

@@ -910,13 +910,14 @@ class MongoDBEngine:
 
     def get_memory_service(self, slug: str) -> Any | None:
         """
-        Get Mem0 memory service for an app.
+        Get memory service for an app (returns BaseMemoryService instance).
 
         Args:
             slug: App slug
 
         Returns:
-            Mem0MemoryService instance if memory is enabled for this app, None otherwise
+            BaseMemoryService instance (currently Mem0MemoryService) if memory is enabled
+            for this app, None otherwise
 
         Example:
             ```python

mdb_engine/core/service_initialization.py

@@ -63,10 +63,10 @@ class ServiceInitializer:
         self, slug: str, memory_config: dict[str, Any] | None
     ) -> None:
         """
-        Initialize Mem0 memory service for an app.
+        Initialize memory service for an app (defaults to Mem0 implementation).
 
         Memory support is OPTIONAL - only processes if dependencies are available.
-        mem0 handles embeddings and LLM via environment variables (.env).
+        Currently uses Mem0.ai which handles embeddings and LLM via environment variables (.env).
 
         Args:
             slug: App slug
@@ -356,13 +356,14 @@ class ServiceInitializer:
 
     def get_memory_service(self, slug: str) -> Any | None:
         """
-        Get Mem0 memory service for an app.
+        Get memory service for an app (returns BaseMemoryService instance).
 
         Args:
             slug: App slug
 
         Returns:
-            Mem0MemoryService instance if memory is enabled for this app, None otherwise
+            BaseMemoryService instance (currently Mem0MemoryService) if memory is enabled
+            for this app, None otherwise
         """
         try:
             service = self._memory_services.get(slug)

mdb_engine/core/types.py

@@ -11,9 +11,9 @@ This module is part of MDB_ENGINE - MongoDB Engine.
 from typing import TYPE_CHECKING, Any, Literal, TypedDict
 
 if TYPE_CHECKING:
-    from ..memory import Mem0MemoryService
+    from ..memory import BaseMemoryService
 else:
-    Mem0MemoryService = Any
+    BaseMemoryService = Any
 
 
 # ============================================================================

mdb_engine/dependencies.py

@@ -33,7 +33,7 @@ if TYPE_CHECKING:
     from .core.engine import MongoDBEngine
     from .database.scoped_wrapper import ScopedMongoWrapper
     from .embeddings.service import EmbeddingService
-    from .memory.service import Mem0MemoryService
+    from .memory import BaseMemoryService
 
 logger = logging.getLogger(__name__)
 
@@ -121,8 +121,8 @@ async def get_embedding_service(request: Request) -> "EmbeddingService":
         raise HTTPException(503, f"Failed to initialize embedding service: {e}") from e
 
 
-async def get_memory_service(request: Request) -> Optional["Mem0MemoryService"]:
-    """Get the Mem0 memory service if configured."""
+async def get_memory_service(request: Request) -> Optional["BaseMemoryService"]:
+    """Get the memory service if configured (defaults to Mem0 implementation)."""
     engine = getattr(request.app.state, "engine", None)
     slug = getattr(request.app.state, "app_slug", None)
     if not engine or not slug:

mdb_engine/memory/README.md

@@ -2,9 +2,37 @@
 
 Mem0.ai integration for intelligent memory management in MDB_ENGINE applications. Provides semantic memory storage, retrieval, and inference capabilities with MongoDB integration.
 
+## 🎉 What's New
+
+### Extensible Architecture (Latest)
+
+**Base Class Pattern for Future Extensibility!**
+
+The memory service now uses an abstract base class pattern, enabling future memory provider implementations while maintaining backward compatibility:
+
+- **🏗️ BaseMemoryService**: Abstract base class defining the memory service interface
+- **🔌 Provider Extensibility**: Easy to add new memory providers (LangChain, custom implementations, etc.)
+- **✅ Backward Compatible**: All existing code continues to work without changes
+- **📝 Type Safety**: Better IDE support and type checking with abstract base class
+- **🎯 Consistent API**: All memory providers implement the same interface
+
+### v0.7.4 Enhancements
+
+**Enhanced Mem0 Integration - Production Ready!**
+
+- **🔧 Hybrid Update Pattern**: Content updates via Mem0 (triggers re-embedding), metadata updates via direct MongoDB (full control, no API limitations)
+- **📊 Direct MongoDB Access**: Reliable data retrieval directly from MongoDB, bypassing Mem0 API inconsistencies
+- **🏷️ Full Metadata Support**: Update any metadata field without restrictions - not limited by Mem0's API
+- **✅ Correct Mem0 Structure**: Properly handles Mem0's MongoDB structure (`_id` as document ID, `payload` for memory data)
+- **🛡️ Robust Error Handling**: Specific exception handling with proper KeyboardInterrupt/SystemExit propagation
+- **🔍 Reliable Returns**: Always returns normalized documents fetched directly from MongoDB (guaranteed structure)
+
+> 📖 **Want to understand why we use manual MongoDB access?** See the [Mem0 Implementation Guide](../../docs/guides/MEM0_IMPLEMENTATION.md) for detailed explanations of our architectural decisions, Mem0's MongoDB structure, and things to watch out for.
+
 ## Features
 
-- **Mem0 Integration**: Wrapper around Mem0.ai for intelligent memory management
+- **Extensible Architecture**: Base class pattern allows for multiple memory provider implementations
+- **Mem0 Integration**: Default implementation using Mem0.ai for intelligent memory management
 - **MongoDB Storage**: Built-in MongoDB vector store integration
 - **Auto-Detection**: Automatically detects OpenAI or Azure OpenAI from environment variables
 - **Semantic Search**: Vector-based semantic memory search
@@ -67,7 +95,7 @@ Enable memory service in your `manifest.json`:
 ### Basic Usage
 
 ```python
-from mdb_engine.memory import Mem0MemoryService
+from mdb_engine.memory import BaseMemoryService  # Base class for type hints
 from mdb_engine.core import MongoDBEngine
 
 # Initialize engine
@@ -75,7 +103,8 @@ engine = MongoDBEngine(mongo_uri="...", db_name="...")
 await engine.initialize()
 
 # Get memory service (automatically configured from manifest)
-memory_service = engine.get_memory_service("my_app")
+# Returns BaseMemoryService instance (currently Mem0MemoryService)
+memory_service: BaseMemoryService = engine.get_memory_service("my_app")
 
 # Add memory
 memory = await memory_service.add(
@@ -163,14 +192,17 @@ results = await memory_service.search(
 
 ### Get Memories
 
-Retrieve memories for a user:
+Retrieve memories for a user. The service automatically normalizes Mem0's MongoDB structure (`_id`, `payload`) into a consistent API format:
 
 ```python
 # Get all memories
 all_memories = await memory_service.get_all(user_id="user123")
+# Returns normalized format: [{"id": "...", "memory": "...", "metadata": {...}, ...}]
 
 # Get specific memory
 memory = await memory_service.get(memory_id="memory_123", user_id="user123")
+# Returns normalized format: {"id": "...", "memory": "...", "metadata": {...}, ...}
+# Note: memory_id can be either Mem0's _id or the normalized id field
 
 # Get memories with filters
 memories = await memory_service.get_all(
@@ -179,9 +211,16 @@ memories = await memory_service.get_all(
 )
 ```
 
+**Note**: The service handles Mem0's internal MongoDB structure (`_id` as document ID, `payload` containing memory data) automatically. All methods return normalized documents with consistent `id`, `memory`, `text`, and `metadata` fields.
+
 ### Update Memory
 
-Update existing memories in-place while preserving the original memory ID and creation timestamp:
+Update existing memories using a **hybrid approach** that combines Mem0's embedding capabilities with direct MongoDB control:
+
+**Architecture:**
+- **Content Updates**: Routed via Mem0 (triggers automatic re-embedding)
+- **Metadata Updates**: Routed via direct PyMongo (full control, no API limitations)
+- **Return Value**: Always fetched from MongoDB (guaranteed correct structure)
 
 ```python
 # Update memory content and metadata
@@ -200,14 +239,21 @@ updated = memory_service.update(
     metadata={"updated": True}
 )
 
-# Update only metadata (content unchanged)
+# Update only metadata (content unchanged) - FULLY SUPPORTED
+updated = memory_service.update(
+    memory_id="memory_123",
+    user_id="user123",
+    metadata={"category": "updated", "priority": "high"}
+)
+
+# Update only content (no metadata changes)
 updated = memory_service.update(
     memory_id="memory_123",
     user_id="user123",
-    metadata={"category": "updated"}
+    memory="Updated content only"
 )
 
-# Backward compatibility: using 'data' parameter
+# Using 'data' parameter
 updated = memory_service.update(
     memory_id="memory_123",
     user_id="user123",
@@ -217,12 +263,18 @@ updated = memory_service.update(
 ```
 
 **Key Features:**
+- **Hybrid Architecture**: Mem0 handles embeddings, MongoDB handles data persistence
+- **Full Metadata Support**: Update any metadata field (not limited by Mem0 API)
 - **Preserves Memory ID**: The original memory ID is maintained
 - **Preserves Creation Timestamp**: `created_at` is not modified
 - **Updates Timestamp**: `updated_at` is automatically set to current time
-- **Recomputes Embeddings**: If content changes, the embedding vector is automatically recomputed
-- **Metadata Merging**: New metadata is merged with existing metadata (doesn't replace)
+- **Recomputes Embeddings**: If content changes, the embedding vector is automatically recomputed via Mem0
+- **Reliable Returns**: Always returns the actual document from MongoDB (not Mem0's response format)
 - **Partial Updates**: Can update content only, metadata only, or both
+- **Security**: Validates user_id ownership before allowing updates
+- **Mem0 Structure Aware**: Correctly handles Mem0's MongoDB structure (`_id` as document ID, `payload` for memory data)
+- **Direct MongoDB Access**: Uses PyMongo for reliable data operations, ensuring consistency
+- **Normalized Responses**: All methods return consistent document structure regardless of Mem0's internal format
 
 ### Delete Memory
 
@@ -336,25 +388,93 @@ for memory in insights:
     print(f"Insights: {memory.get('insights')}")
 ```
 
+## Architecture
+
+### Base Class Pattern
+
+The memory service uses an abstract base class pattern for extensibility:
+
+```python
+from mdb_engine.memory import BaseMemoryService, MemoryServiceError
+
+# BaseMemoryService defines the interface
+# Mem0MemoryService implements it (default provider)
+# Future providers can inherit from BaseMemoryService
+```
+
+**Benefits:**
+- **Type Safety**: Use `BaseMemoryService` for type hints
+- **Extensibility**: Easy to add new providers (LangChain, custom, etc.)
+- **Consistency**: All providers implement the same interface
+- **Backward Compatible**: Existing code works without changes
+
+### Creating Custom Memory Providers
+
+To create a custom memory provider, inherit from `BaseMemoryService`:
+
+```python
+from mdb_engine.memory import BaseMemoryService, MemoryServiceError
+
+class CustomMemoryService(BaseMemoryService):
+    """Custom memory service implementation."""
+    
+    def __init__(self, mongo_uri: str, db_name: str, app_slug: str, config: dict | None = None):
+        # Initialize your custom implementation
+        pass
+    
+    def add(self, messages, user_id=None, metadata=None, **kwargs):
+        # Implement add method
+        pass
+    
+    # Implement all other abstract methods...
+    def get_all(self, user_id=None, limit=100, filters=None, **kwargs):
+        pass
+    
+    def search(self, query, user_id=None, limit=5, filters=None, **kwargs):
+        pass
+    
+    def get(self, memory_id, user_id=None, **kwargs):
+        pass
+    
+    def delete(self, memory_id, user_id=None, **kwargs):
+        pass
+    
+    def delete_all(self, user_id=None, **kwargs):
+        pass
+    
+    def update(self, memory_id, user_id=None, memory=None, metadata=None, **kwargs):
+        pass
+```
+
 ## API Reference
 
+### BaseMemoryService
+
+Abstract base class for all memory service implementations. Defines the standard interface.
+
 ### Mem0MemoryService
 
+Default implementation using Mem0.ai. Inherits from `BaseMemoryService`.
+
 #### Initialization
 
 ```python
 Mem0MemoryService(
     mongo_uri: str,
     db_name: str,
-    collection_name: str = "memories",
-    app_slug: str = None,
-    embedding_model: str = "text-embedding-3-small",
-    embedding_dimensions: int = None,
-    chat_model: str = "gpt-4",
-    temperature: float = 0.7,
-    infer: bool = True,
-    enable_graph: bool = False,
-    config: dict = None
+    app_slug: str,
+    config: dict = None  # Optional configuration
+)
+
+# Or use the factory function
+from mdb_engine.memory import get_memory_service
+
+memory_service = get_memory_service(
+    mongo_uri="...",
+    db_name="...",
+    app_slug="...",
+    config={...},
+    provider="mem0"  # Default, future providers can be specified here
 )
 ```
 
@@ -513,15 +633,19 @@ knowledge = await memory_service.search(
 ## Error Handling
 
 ```python
-from mdb_engine.memory import Mem0MemoryServiceError
+from mdb_engine.memory import MemoryServiceError, Mem0MemoryServiceError
 
 try:
     memory = await memory_service.add(
         messages=[{"role": "user", "content": "Test"}],
         user_id="user123"
     )
-except Mem0MemoryServiceError as e:
+except MemoryServiceError as e:
+    # Base exception for all memory service errors
     print(f"Memory service error: {e}")
+except Mem0MemoryServiceError as e:
+    # Specific exception for Mem0 implementation
+    print(f"Mem0 memory service error: {e}")
 except (ValueError, TypeError, ConnectionError) as e:
     print(f"Configuration or connection error: {e}")
 ```

mdb_engine/memory/__init__.py

@@ -14,16 +14,25 @@ Key Features:
 - **Optional LLM Inference**: Can leverage LLM service for automatic memory
   extraction (set infer: false to disable)
 - **Graph Support**: Optional knowledge graph construction for entity relationships
+- **Extensible Architecture**: Base class allows for future memory provider implementations
 
 Dependencies:
     pip install mem0ai
 """
 
+# Import base classes
+from .base import BaseMemoryService, MemoryServiceError
+
 # Import service components (mem0 import is lazy within service.py)
 from .service import Mem0MemoryService, Mem0MemoryServiceError, get_memory_service
 
 __all__ = [
+    # Base classes (for extensibility)
+    "BaseMemoryService",
+    "MemoryServiceError",
+    # Mem0 implementation (default)
     "Mem0MemoryService",
     "Mem0MemoryServiceError",
+    # Factory function
     "get_memory_service",
 ]

mdb_engine/memory/base.py

@@ -0,0 +1,194 @@
+"""
+Base Memory Service Interface
+
+Abstract base class for memory service implementations.
+This allows for extensibility with different memory providers (Mem0, LangChain, custom, etc.)
+while maintaining a consistent API.
+
+This module is part of MDB_ENGINE - MongoDB Engine.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class MemoryServiceError(Exception):
+    """Base exception for all memory service errors."""
+
+    pass
+
+
+class BaseMemoryService(ABC):
+    """
+    Abstract base class for memory service implementations.
+
+    This class defines the interface that all memory service implementations must follow.
+    Concrete implementations (e.g., Mem0MemoryService) inherit from this class and
+    implement the abstract methods.
+
+    All memory operations are scoped per user_id for safety and data isolation.
+    """
+
+    @abstractmethod
+    def add(
+        self,
+        messages: str | list[dict[str, str]],
+        user_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        bucket_id: str | None = None,
+        bucket_type: str | None = None,
+        raw_content: str | None = None,
+        **kwargs,
+    ) -> list[dict[str, Any]]:
+        """
+        Add memories with user scoping and metadata convenience.
+
+        Args:
+            messages: Memory content as a string or list of message dicts
+            user_id: User ID for scoping (optional but recommended)
+            metadata: Additional metadata to store with the memory
+            bucket_id: Bucket ID for organizing memories
+            bucket_type: Type of bucket (e.g., "general", "file", "conversation")
+            raw_content: Raw content to store alongside extracted facts
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            List of created memory objects with their IDs and metadata
+        """
+        pass
+
+    @abstractmethod
+    def get_all(
+        self,
+        user_id: str | None = None,
+        limit: int = 100,
+        filters: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> list[dict[str, Any]]:
+        """
+        Get all memories with optional filtering.
+
+        Args:
+            user_id: User ID to filter memories (optional)
+            limit: Maximum number of memories to return
+            filters: Additional filters to apply (provider-specific)
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            List of memory objects
+        """
+        pass
+
+    @abstractmethod
+    def search(
+        self,
+        query: str,
+        user_id: str | None = None,
+        limit: int = 5,
+        filters: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> list[dict[str, Any]]:
+        """
+        Perform semantic search across memories.
+
+        Args:
+            query: Search query string
+            user_id: User ID to scope search (optional)
+            limit: Maximum number of results to return
+            filters: Additional metadata filters to apply
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            List of memory objects matching the query, ordered by relevance
+        """
+        pass
+
+    @abstractmethod
+    def get(
+        self,
+        memory_id: str,
+        user_id: str | None = None,
+        **kwargs,
+    ) -> dict[str, Any] | None:
+        """
+        Get a single memory by ID.
+
+        Args:
+            memory_id: Unique identifier for the memory
+            user_id: User ID for security scoping (optional)
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            Memory object if found, None otherwise
+        """
+        pass
+
+    @abstractmethod
+    def delete(
+        self,
+        memory_id: str,
+        user_id: str | None = None,
+        **kwargs,
+    ) -> bool:
+        """
+        Delete a single memory by ID.
+
+        Args:
+            memory_id: Unique identifier for the memory to delete
+            user_id: User ID for security scoping (optional)
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            True if deletion was successful, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def delete_all(
+        self,
+        user_id: str | None = None,
+        **kwargs,
+    ) -> bool:
+        """
+        Delete all memories for a user.
+
+        Args:
+            user_id: User ID whose memories should be deleted (optional)
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            True if deletion was successful, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def update(
+        self,
+        memory_id: str,
+        user_id: str | None = None,
+        memory: str | None = None,
+        data: str | dict[str, Any] | None = None,
+        messages: str | list[dict[str, str]] | None = None,
+        metadata: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> dict[str, Any] | None:
+        """
+        Update an existing memory's content and/or metadata.
+
+        Args:
+            memory_id: Unique identifier for the memory to update (required)
+            user_id: User ID for security scoping (optional)
+            memory: New memory content as a string (optional)
+            data: Alternative parameter for content (string or dict) (optional)
+            messages: Alternative way to provide content as messages (optional)
+            metadata: Metadata updates (optional)
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            Updated memory object if successful, None if memory not found
+
+        Raises:
+            MemoryServiceError: If update operation fails
+            ValueError: If memory_id is invalid or empty
+        """
+        pass

mdb_engine/memory/service.py

@@ -1,13 +1,37 @@
 """
 Mem0 Memory Service Implementation
 Production-ready wrapper for Mem0.ai with strict metadata schema for MongoDB.
+
+v0.7.4: Enhanced with hybrid update pattern and direct MongoDB access for reliable
+memory operations. Properly handles Mem0's MongoDB structure (_id, payload).
 """
 
 import logging
 import os
 import tempfile
+from datetime import datetime
 from typing import Any
 
+from .base import BaseMemoryService, MemoryServiceError
+
+# Required: Direct PyMongo access
+try:
+    from pymongo import MongoClient
+    from pymongo.errors import (
+        ConfigurationError,
+        ConnectionFailure,
+        InvalidURI,
+        PyMongoError,
+        ServerSelectionTimeoutError,
+    )
+except ImportError:
+    MongoClient = None
+    ConnectionFailure = None
+    ConfigurationError = None
+    ServerSelectionTimeoutError = None
+    InvalidURI = None
+    PyMongoError = None
+
 # Set MEM0_DIR environment variable early to avoid permission issues
 if "MEM0_DIR" not in os.environ:
     mem0_dir = os.path.join(tempfile.gettempdir(), ".mem0")
@@ -39,23 +63,29 @@ def _check_mem0_available():
 logger = logging.getLogger(__name__)
 
 
-class Mem0MemoryServiceError(Exception):
+class Mem0MemoryServiceError(MemoryServiceError):
+    """Exception raised by Mem0MemoryService operations."""
+
     pass
 
 
-class Mem0MemoryService:
+class Mem0MemoryService(BaseMemoryService):
     """
     Production-ready Mem0 Memory Service with MongoDB integration.
 
     Features:
+    - Hybrid update pattern: Mem0 for embeddings, MongoDB for data persistence
+    - Full metadata support via direct MongoDB access
     - In-place memory updates preserving IDs and timestamps
     - Automatic embedding recomputation on content changes
     - Knowledge graph support (if enabled in Mem0 config)
     - Comprehensive error handling and logging
-    - Backward compatibility with existing code
+    - Reliable return values fetched directly from MongoDB
 
-    All operations go through Mem0's API to ensure proper state management,
-    graph updates, and relationship handling.
+    Update Architecture:
+    - Content updates routed via Mem0 (triggers re-embedding)
+    - Metadata updates routed via direct PyMongo (full control)
+    - Final result always fetched from MongoDB (guaranteed structure)
     """
 
     def __init__(
@@ -77,6 +107,26 @@ class Mem0MemoryService:
         self.collection_name = (config or {}).get("collection_name", f"{app_slug}_memories")
         self.infer = (config or {}).get("infer", True)
 
+        # ---------------------------------------------------------
+        # 1. SETUP DIRECT MONGODB ACCESS (The "Backdoor")
+        # ---------------------------------------------------------
+        if MongoClient is None:
+            raise Mem0MemoryServiceError("pymongo is required. pip install pymongo")
+
+        try:
+            self._client = MongoClient(mongo_uri)
+            self._db = self._client[db_name]
+            self.memories_collection = self._db[self.collection_name]
+            logger.info(f"✅ Direct MongoDB connection established for {self.collection_name}")
+        except BaseException as e:
+            # MongoDB connection may raise various exceptions. We catch BaseException
+            # (not Exception) to ensure we always raise Mem0MemoryServiceError for
+            # consistent error handling, but we re-raise KeyboardInterrupt and SystemExit
+            # to allow proper shutdown.
+            if isinstance(e, KeyboardInterrupt | SystemExit):
+                raise
+            raise Mem0MemoryServiceError(f"Failed to connect to MongoDB directly: {e}") from e
+
         # Ensure GOOGLE_API_KEY is set for mem0 compatibility
         # (mem0 expects GOOGLE_API_KEY, not GEMINI_API_KEY)
         # This ensures we use the DIRECT Gemini API
@@ -437,8 +487,50 @@ class Mem0MemoryService:
             return []
 
     def get(self, memory_id: str, user_id: str | None = None, **kwargs) -> dict[str, Any]:
+        """
+        Get memory by ID using direct MongoDB access for reliability.
+
+        Mem0 stores memories with _id as the MongoDB document ID.
+        Memory content and metadata are stored in the 'payload' field.
+        """
         try:
-            return self.memory.get(memory_id, **kwargs)
+            # Mem0 uses _id as the MongoDB document ID
+            doc = self.memories_collection.find_one({"_id": memory_id})
+            if doc:
+                # Extract payload (where Mem0 stores the actual memory data)
+                payload = doc.get("payload", {})
+
+                # Build normalized memory document
+                memory_doc = {
+                    "id": str(doc["_id"]),  # Convert _id to id for API consistency
+                    "memory": payload.get("memory") or payload.get("text"),
+                    "text": payload.get("text") or payload.get("memory"),
+                    "metadata": payload.get("metadata", {}),
+                    "user_id": payload.get("user_id") or payload.get("metadata", {}).get("user_id"),
+                    "created_at": payload.get("created_at"),
+                    "updated_at": payload.get("updated_at"),
+                }
+
+                # Add any other payload fields
+                for key, value in payload.items():
+                    if key not in [
+                        "memory",
+                        "text",
+                        "metadata",
+                        "user_id",
+                        "created_at",
+                        "updated_at",
+                    ]:
+                        memory_doc[key] = value
+
+                # Optional: Filter by user_id if provided
+                if user_id:
+                    doc_user_id = memory_doc.get("user_id")
+                    if doc_user_id and str(doc_user_id) != str(user_id):
+                        return None
+
+                return memory_doc
+            return None
         except (
             ValueError,
             TypeError,
@@ -448,7 +540,19 @@ class Mem0MemoryService:
             RuntimeError,
             KeyError,
         ):
-            return None
+            # Fallback to Mem0 if direct access fails
+            try:
+                return self.memory.get(memory_id, **kwargs)
+            except (
+                ValueError,
+                TypeError,
+                ConnectionError,
+                OSError,
+                AttributeError,
+                RuntimeError,
+                KeyError,
+            ):
+                return None
 
     def delete(self, memory_id: str, user_id: str | None = None, **kwargs) -> bool:
         try:
@@ -491,15 +595,27 @@ class Mem0MemoryService:
         **kwargs,
     ) -> dict[str, Any] | None:
         """
-        Update an existing memory in-place with production-grade error handling.
+        Robust Hybrid Update Pattern:
+
+        This method uses a hybrid approach that combines Mem0's embedding capabilities
+        with direct MongoDB control for maximum flexibility and reliability.
+
+        **Architecture:**
+        1. **Content Updates** → Routed via Mem0 (triggers automatic re-embedding)
+        2. **Metadata Updates** → Routed via direct PyMongo (full control, no API limitations)
+        3. **Return Value** → Always fetched from MongoDB (guaranteed correct structure)
+
+        **Why Hybrid?**
+        - Mem0's update() API doesn't support metadata parameter
+        - Mem0's return values can be inconsistent (dict, list, or status messages)
+        - Direct MongoDB access gives us full control over data persistence
+        - We use Mem0 purely as an "embedding utility" for content changes
 
         Updates the memory content and/or metadata while preserving:
         - Original memory ID (never changes)
         - Creation timestamp (created_at) - preserved
         - Other existing fields - preserved unless explicitly updated
 
-        If content is updated, the embedding vector is automatically recomputed.
-
         Args:
             memory_id: The ID of the memory to update (required)
             user_id: The user ID who owns the memory (for scoping and security)
@@ -508,12 +624,13 @@ class Mem0MemoryService:
                   Can be a string or dict with 'memory'/'text'/'content' key.
             messages: Alternative way to provide content as messages (optional).
                       Can be a string or list of dicts with 'content' key.
-            metadata: Metadata updates (optional, but NOT SUPPORTED by Mem0 update API).
-                     This parameter is accepted for API consistency but will be ignored.
+            metadata: Metadata updates (FULLY SUPPORTED via direct MongoDB).
+                     Can update any metadata field, not limited by Mem0 API.
             **kwargs: Additional arguments passed to Mem0 operations
 
         Returns:
-            Updated memory object with same ID, or None if memory not found
+            Updated memory object with same ID, fetched directly from MongoDB,
+            or None if memory not found
 
         Raises:
             Mem0MemoryServiceError: If update operation fails
@@ -521,7 +638,7 @@ class Mem0MemoryService:
 
         Example:
             ```python
-            # Update content and metadata
+            # Update content and metadata (hybrid approach)
             updated = memory_service.update(
                 memory_id="04f78986-dfad-46fe-8381-034bbee9a2fc",
                 user_id="user123",
@@ -529,78 +646,164 @@ class Mem0MemoryService:
                 metadata={"category": "technical", "updated": True}
             )
 
-            # Update only metadata (content unchanged)
+            # Update only metadata (content unchanged) - FULLY SUPPORTED
             updated = memory_service.update(
                 memory_id="04f78986-dfad-46fe-8381-034bbee9a2fc",
                 user_id="user123",
-                metadata={"category": "updated"}
+                metadata={"category": "updated", "priority": "high"}
+            )
+
+            # Update only content (no metadata)
+            updated = memory_service.update(
+                memory_id="04f78986-dfad-46fe-8381-034bbee9a2fc",
+                user_id="user123",
+                memory="Updated content only"
             )
             ```
         """
         if not memory_id or not isinstance(memory_id, str) or not memory_id.strip():
             raise ValueError("memory_id is required and must be a non-empty string")
 
-        try:
-            # Normalize data parameter (alternative to memory parameter)
-            normalized_memory = self._normalize_content_input(memory, data, messages)
-            normalized_metadata = self._normalize_metadata_input(metadata, data)
+        # 1. Normalize Inputs
+        normalized_memory = self._normalize_content_input(memory, data, messages)
+        normalized_metadata = self._normalize_metadata_input(metadata, data)
 
-            existing_memory = self.get(memory_id=memory_id, user_id=user_id, **kwargs)
-            if not existing_memory:
-                logger.warning(
-                    f"Memory {memory_id} not found for update",
-                    extra={"memory_id": memory_id, "user_id": user_id},
-                )
+        # 2. Check Existence (Fast check via ID)
+        # Mem0 uses _id as the MongoDB document ID
+        existing = self.memories_collection.find_one(
+            {"_id": memory_id}, {"_id": 1, "payload.user_id": 1, "payload.metadata.user_id": 1}
+        )
+        if not existing:
+            logger.warning(f"Memory {memory_id} not found.")
+            return None
+
+        # Optional: Security Scope Check
+        # Check user_id in payload (Mem0 stores it there)
+        if user_id:
+            payload = existing.get("payload", {})
+            existing_user_id = payload.get("user_id") or payload.get("metadata", {}).get("user_id")
+            if existing_user_id and str(existing_user_id) != str(user_id):
+                logger.warning(f"Unauthorized update attempt for {memory_id} by {user_id}")
                 return None
 
-            # Use Mem0's built-in update method
-            # Mem0's Memory class update method handles:
-            # - In-place updates preserving memory ID
-            # - Automatic embedding recomputation
-            # - Metadata merging
-            # - User scoping
-            # - Knowledge graph updates (if enabled)
-            # - Relationship management
-            if not hasattr(self.memory, "update") or not callable(self.memory.update):
-                raise Mem0MemoryServiceError(
-                    "Mem0 update method not available. "
-                    "Please ensure you're using a compatible version of mem0ai "
-                    "that supports updates. Install with: pip install --upgrade mem0ai"
-                )
+        # Use _id directly (Mem0's format)
+        actual_id = memory_id
 
-            result = self._update_via_mem0(
-                memory_id=memory_id,
-                user_id=user_id,
-                memory=normalized_memory,
-                metadata=normalized_metadata,
-                **kwargs,
-            )
+        try:
+            # -------------------------------------------------
+            # STEP A: Content Update (Via Mem0 for Vectors)
+            # -------------------------------------------------
+            if normalized_memory:
+                logger.info(f"📝 Updating content for {actual_id} (triggering re-embedding)")
+                # We use Mem0 here specifically because it handles the embedding logic.
+                # We do NOT care what it returns.
+                try:
+                    # Use the actual_id (which Mem0 recognizes)
+                    self.memory.update(memory_id=actual_id, data=normalized_memory)
+                except BaseException as e:
+                    # Mem0 is a third-party library that may raise any exception.
+                    # We catch BaseException (not Exception) to ensure we always raise
+                    # Mem0MemoryServiceError for consistent error handling, but we
+                    # re-raise KeyboardInterrupt and SystemExit to allow proper shutdown.
+                    if isinstance(e, KeyboardInterrupt | SystemExit):
+                        raise
+                    # If Mem0 fails (e.g. LLM rate limit, API error), we should abort
+                    # or fall back to just text update without vector (risky for search).
+                    logger.exception(f"Mem0 embedding update failed: {e}")
+                    raise Mem0MemoryServiceError(f"Content update failed: {e}") from e
+
+            # -------------------------------------------------
+            # STEP B: Metadata Update (Direct PyMongo)
+            # -------------------------------------------------
+            if normalized_metadata:
+                logger.info(f"🏷️ Updating metadata for {actual_id}")
+
+                # Ensure user_id is in metadata for consistency
+                if user_id:
+                    normalized_metadata["user_id"] = str(user_id)
+
+                # Mem0 stores everything in the 'payload' field
+                # We need to update payload.metadata and payload.user_id
+                update_fields = {}
+
+                # Handle metadata updates (nested under payload.metadata)
+                for k, v in normalized_metadata.items():
+                    if k == "user_id":
+                        # user_id can be at payload.user_id or payload.metadata.user_id
+                        update_fields["payload.user_id"] = v
+                        update_fields["payload.metadata.user_id"] = v
+                    else:
+                        update_fields[f"payload.metadata.{k}"] = v
+
+                # Add timestamp to payload
+                update_fields["payload.updated_at"] = datetime.utcnow().isoformat()
+
+                # Execute Atomic Update - Mem0 uses _id
+                self.memories_collection.update_one({"_id": actual_id}, {"$set": update_fields})
+
+            # -------------------------------------------------
+            # STEP C: Return The Truth (Direct DB Fetch)
+            # -------------------------------------------------
+            # We completely ignore Mem0's return value (which might be {"message": "ok"})
+            # and fetch the actual document from the database.
+            final_doc_raw = self.memories_collection.find_one({"_id": actual_id})
+
+            if final_doc_raw:
+                # Extract payload (where Mem0 stores the actual memory data)
+                payload = final_doc_raw.get("payload", {})
+
+                # Build normalized memory document (same format as get() method)
+                final_doc = {
+                    "id": str(final_doc_raw["_id"]),  # Convert _id to id for API consistency
+                    "memory": payload.get("memory") or payload.get("text"),
+                    "text": payload.get("text") or payload.get("memory"),
+                    "metadata": payload.get("metadata", {}),
+                    "user_id": payload.get("user_id") or payload.get("metadata", {}).get("user_id"),
+                    "created_at": payload.get("created_at"),
+                    "updated_at": payload.get("updated_at"),
+                }
 
-            if result is None:
-                logger.warning(
-                    f"Mem0 update returned None for memory {memory_id}",
-                    extra={"memory_id": memory_id, "user_id": user_id},
-                )
-                return None
+                # Add any other payload fields
+                for key, value in payload.items():
+                    if key not in [
+                        "memory",
+                        "text",
+                        "metadata",
+                        "user_id",
+                        "created_at",
+                        "updated_at",
+                    ]:
+                        final_doc[key] = value
+
+                # Ensure date objects are serialized if your downstream expects strings
+                if isinstance(final_doc.get("created_at"), datetime):
+                    final_doc["created_at"] = final_doc["created_at"].isoformat()
+                if isinstance(final_doc.get("updated_at"), datetime):
+                    final_doc["updated_at"] = final_doc["updated_at"].isoformat()
+            else:
+                final_doc = None
 
             logger.info(
-                f"Successfully updated memory {memory_id} using Mem0 update method",
+                f"Successfully updated memory {memory_id}",
                 extra={
                     "memory_id": memory_id,
                     "content_updated": bool(normalized_memory),
                     "metadata_updated": bool(normalized_metadata),
                 },
             )
-            return result
+            return final_doc
 
         except ValueError:
             # Re-raise validation errors as-is
             raise
-        except (AttributeError, TypeError, ValueError, KeyError) as e:
-            logger.exception(
-                f"Error updating memory {memory_id}",
-                extra={"memory_id": memory_id, "user_id": user_id},
-            )
+        except BaseException as e:
+            # Catch any unexpected errors during update. We catch BaseException
+            # (not Exception) to ensure we always raise Mem0MemoryServiceError for
+            # consistent error handling, but we re-raise KeyboardInterrupt and SystemExit
+            # to allow proper shutdown.
+            if isinstance(e, KeyboardInterrupt | SystemExit):
+                raise
+            logger.exception(f"Critical error during memory update for {memory_id}")
             raise Mem0MemoryServiceError(f"Update failed: {e}") from e
 
     def _normalize_content_input(
@@ -609,122 +812,45 @@ class Mem0MemoryService:
         data: str | dict[str, Any] | None,
         messages: str | list[dict[str, str]] | None,
     ) -> str | None:
-        """
-        Normalize content input from various parameter formats.
-
-        Priority: memory > data > messages
-        """
-        # Already have memory content
-        if memory:
+        """Normalize content input from various parameter formats."""
+        if memory is not None:
             if not isinstance(memory, str):
-                raise TypeError("memory parameter must be a string")
+                raise TypeError(f"memory parameter must be a string, got {type(memory).__name__}")
             return memory.strip() if memory.strip() else None
-
-        # Check data parameter
-        if data:
+        if data is not None:
             if isinstance(data, str):
                 return data.strip() if data.strip() else None
-            elif isinstance(data, dict):
-                content = data.get("memory") or data.get("text") or data.get("content")
-                if content and isinstance(content, str):
-                    return content.strip() if content.strip() else None
-
-        # Check messages parameter
-        if messages:
+            if isinstance(data, dict):
+                return data.get("memory") or data.get("text") or data.get("content")
+            raise TypeError(f"data parameter must be a string or dict, got {type(data).__name__}")
+        if messages is not None:
             if isinstance(messages, str):
                 return messages.strip() if messages.strip() else None
-            elif isinstance(messages, list):
-                content_parts = []
-                for msg in messages:
-                    if isinstance(msg, dict) and "content" in msg:
-                        content = msg["content"]
-                        if isinstance(content, str) and content.strip():
-                            content_parts.append(content.strip())
-                if content_parts:
-                    return " ".join(content_parts)
-
+            if isinstance(messages, list):
+                return " ".join([m.get("content", "") for m in messages if isinstance(m, dict)])
+            raise TypeError(
+                f"messages parameter must be a string or list, got {type(messages).__name__}"
+            )
         return None
 
     def _normalize_metadata_input(
         self, metadata: dict[str, Any] | None, data: dict[str, Any] | None
     ) -> dict[str, Any] | None:
         """Normalize metadata input, extracting from data dict if needed."""
-        if metadata is not None and not isinstance(metadata, dict):
-            raise TypeError("metadata must be a dict or None")
-
-        # If metadata provided directly, use it
         if metadata is not None:
+            if not isinstance(metadata, dict):
+                raise TypeError(f"metadata parameter must be a dict, got {type(metadata).__name__}")
             return metadata
-
-        # Check if metadata is in data dict
-        if isinstance(data, dict) and "metadata" in data:
-            data_metadata = data.get("metadata")
-            if isinstance(data_metadata, dict):
-                return data_metadata
-
+        if data is not None and isinstance(data, dict):
+            metadata_from_data = data.get("metadata")
+            if metadata_from_data is not None and not isinstance(metadata_from_data, dict):
+                raise TypeError(
+                    f"metadata in data parameter must be a dict, "
+                    f"got {type(metadata_from_data).__name__}"
+                )
+            return metadata_from_data
         return None
 
-    def _update_via_mem0(
-        self,
-        memory_id: str,
-        user_id: str | None,
-        memory: str | None,
-        metadata: dict[str, Any] | None,
-        **kwargs,
-    ) -> dict[str, Any] | None:
-        """
-        Update memory using Mem0's built-in update method.
-
-        Note: Mem0's update() only supports content updates (text parameter).
-        Metadata updates are not supported by the Mem0 API.
-
-        Args:
-            memory_id: Memory ID to update
-            user_id: User ID for scoping (not used in update call)
-            memory: New memory content (normalized)
-            metadata: Metadata to merge (ignored - not supported by Mem0 update API)
-            **kwargs: Additional arguments passed to Mem0
-
-        Returns:
-            Updated memory dict or None if not found
-        """
-        # Filter out user_id from kwargs to prevent passing it as a direct parameter
-        filtered_kwargs = {k: v for k, v in kwargs.items() if k != "user_id"}
-
-        logger.debug(
-            f"Calling mem0.update() for memory_id={memory_id}",
-            extra={
-                "memory_id": memory_id,
-                "has_content": bool(memory),
-                "has_metadata": bool(metadata),
-                "user_id": user_id,
-            },
-        )
-
-        if metadata:
-            logger.warning(
-                f"Metadata update requested for memory {memory_id} but Mem0 update() "
-                f"does not support metadata parameter. Metadata will not be updated."
-            )
-
-        update_kwargs = {"memory_id": memory_id}
-        if memory:
-            update_kwargs["data"] = memory
-        update_kwargs.update(filtered_kwargs)
-
-        result = self.memory.update(**update_kwargs)
-
-        # Note: Mem0's update() doesn't support metadata parameter
-        # Metadata updates would require direct MongoDB access, which we avoid
-
-        # Normalize result to dict
-        if isinstance(result, dict):
-            return result
-        elif isinstance(result, list) and len(result) > 0:
-            return result[0] if isinstance(result[0], dict) else None
-        else:
-            return self.get(memory_id=memory_id)
-
     def _normalize_result(self, result: Any) -> list[dict[str, Any]]:
         """Normalize Mem0's return type (dict vs list)."""
         if result is None:
@@ -740,5 +866,35 @@ class Mem0MemoryService:
         return []
 
 
-def get_memory_service(mongo_uri, db_name, app_slug, config=None):
-    return Mem0MemoryService(mongo_uri, db_name, app_slug, config)
+def get_memory_service(
+    mongo_uri: str,
+    db_name: str,
+    app_slug: str,
+    config: dict[str, Any] | None = None,
+    provider: str = "mem0",
+) -> BaseMemoryService:
+    """
+    Factory function to create a memory service instance.
+
+    Args:
+        mongo_uri: MongoDB connection URI
+        db_name: Database name
+        app_slug: Application slug for scoping
+        config: Memory service configuration dictionary
+        provider: Memory provider to use (default: "mem0")
+
+    Returns:
+        BaseMemoryService instance (concrete implementation based on provider)
+
+    Raises:
+        ValueError: If provider is not supported
+        Mem0MemoryServiceError: If Mem0 provider fails to initialize
+    """
+    if provider == "mem0":
+        return Mem0MemoryService(mongo_uri, db_name, app_slug, config)
+    else:
+        raise ValueError(
+            f"Unsupported memory provider: {provider}. "
+            f"Supported providers: mem0. "
+            f"Future providers can be added by implementing BaseMemoryService."
+        )

{mdb_engine-0.7.3.dist-info → mdb_engine-0.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdb-engine
-Version: 0.7.3
+Version: 0.7.4
 Summary: MongoDB Engine
 Home-page: https://github.com/ranfysvalle02/mdb-engine
 Author: Fabian Valle

{mdb_engine-0.7.3.dist-info → mdb_engine-0.7.4.dist-info}/RECORD

@@ -1,8 +1,8 @@
 mdb_engine/README.md,sha256=T3EFGcPopY9LslYW3lxgG3hohWkAOmBNbYG0FDMUJiY,3502
-mdb_engine/__init__.py,sha256=AwWt-MyzGNDl_2YEkTO0-x15qnUw3tF-oiOJJAYGkIs,3097
+mdb_engine/__init__.py,sha256=OkNHx17I4f8jI5IAJGK0HbSTrZrUVnl1QlvtPZLri-I,3097
 mdb_engine/config.py,sha256=DTAyxfKB8ogyI0v5QR9Y-SJOgXQr_eDBCKxNBSqEyLc,7269
 mdb_engine/constants.py,sha256=eaotvW57TVOg7rRbLziGrVNoP7adgw_G9iVByHezc_A,7837
-mdb_engine/dependencies.py,sha256=MJuYQhZ9ZGzXlip1ha5zba9Rvn04HDPWahJFJH81Q2s,14107
+mdb_engine/dependencies.py,sha256=F2_hbtK-lyeqB_iPeJVCh8jFbHi7sx0fduCUCNCKoUc,14128
 mdb_engine/exceptions.py,sha256=NkBSdTBNP9bVTtI6w6mAoEfeVZDq-Bg7vCF2L26ZDZo,8442
 mdb_engine/auth/ARCHITECTURE.md,sha256=JXZsjEIpNz4Szk18KaOiEabhEuz1pmYWXQRN-EJEHDM,4076
 mdb_engine/auth/README.md,sha256=IVlUOat96V3yM6wk4T-u4GxJ4-WF05eBSJBlvIexyBo,37285
@@ -35,7 +35,7 @@ mdb_engine/auth/utils.py,sha256=YkexCo0xV37mpOJUI32cntRHVOUUS7r19TIMPWHcgpA,2734
 mdb_engine/auth/websocket_sessions.py,sha256=7eFNagY2K3Rp1x7d_cO5JcpT-DrYkc__cmVhl6pAC2M,15081
 mdb_engine/auth/websocket_tickets.py,sha256=VoIArcnQBtYqXRMs-5m7NSvCJB1dEeHrLl7j7yG-H-A,9887
 mdb_engine/cli/__init__.py,sha256=PANRi4THmL34d1mawlqxIrnuItXMdqoMTq5Z1zHd7rM,301
-mdb_engine/cli/main.py,sha256=qDVVUJOXajdZmbId9AIGBS380U7OlhA8ILrAIfURbSE,811
+mdb_engine/cli/main.py,sha256=4etDTeg4DIPQQ5HdWIwcpg9FWLx21NXF6f2fj4xG8gQ,811
 mdb_engine/cli/utils.py,sha256=bNRGJgdzxUjXAOVe1aoxWJ5M_IqtAE-eW4pfAkwiDDM,2760
 mdb_engine/cli/commands/__init__.py,sha256=ZSzMhKdV9ILD5EbOSxDV9nURHo1e4bQ0c8AWpqsTEqM,115
 mdb_engine/cli/commands/generate.py,sha256=VEcn7qNQkIPQlLEK3oXUBgYMwD-G0FyomXQcWTtKsbs,17304
@@ -48,13 +48,13 @@ mdb_engine/core/app_registration.py,sha256=w7wjrlNQsEekuDQkG6HM4Z5t00E65baEzncnh
 mdb_engine/core/app_secrets.py,sha256=bo-syg9UUATibNyXEZs-0TTYWG-JaY-2S0yNSGA12n0,10524
 mdb_engine/core/connection.py,sha256=XnwuPG34pJ7kJGJ84T0mhj1UZ6_CLz_9qZf6NRYGIS8,8346
 mdb_engine/core/encryption.py,sha256=RZ5LPF5g28E3ZBn6v1IMw_oas7u9YGFtBcEj8lTi9LM,7515
-mdb_engine/core/engine.py,sha256=wSJ99FP3NRUejGCXliwi9fW_pVZPpLjdUMG8FsU5Kms,185252
+mdb_engine/core/engine.py,sha256=tzR5Gh5wTv9ACPYF7Z7aaAUInbF0l0Dtj2HrMB4VFes,185326
 mdb_engine/core/index_management.py,sha256=9-r7MIy3JnjQ35sGqsbj8K_I07vAUWtAVgSWC99lJcE,5555
 mdb_engine/core/manifest.py,sha256=D3OGRjm1It8dmS3IMoxHckHUerhs5PtcQgPz8o5ZL9w,140785
 mdb_engine/core/ray_integration.py,sha256=csAgICl2g7Plqy4N49MJU1Ca-lr8KZznAouXMMRwhG8,13706
 mdb_engine/core/seeding.py,sha256=c5IhdwlqUf_4Q5FFTAhPLaHPaUr_Txo3z_DUwZmWsFs,6421
-mdb_engine/core/service_initialization.py,sha256=N4varRswExBYahAgPfcPtNhqszOjm0JQ0u7r7mfFyqM,15018
-mdb_engine/core/types.py,sha256=u0LDGE4A3txGDlc9PNoQX8jwVYFjJSw4K5LDnpatsNc,11254
+mdb_engine/core/service_initialization.py,sha256=LVCbc911YA07cTdy4UbPC7eho3L_Ub_8aX-HIp4MHq4,15145
+mdb_engine/core/types.py,sha256=MAFAqIR-Oj8CF24jlVnOQevrlXOcME3npIgRAzfZXcA,11254
 mdb_engine/database/README.md,sha256=-31mVxBeVQaYsF3AD1-gQbD2NCYVcPjdFoA6sZ6b02Y,19354
 mdb_engine/database/__init__.py,sha256=rrc3eZFli3K2zrvVdDbMBi8YkmoHYzP6JNT0AUBE5VU,981
 mdb_engine/database/abstraction.py,sha256=H6f2WYY80r3onqN6s139uDSyG9W_QpadaoQ84hJuG1E,23438
@@ -74,9 +74,10 @@ mdb_engine/indexes/README.md,sha256=r7duq-1vtqHhBk1cwoBMYYh_dfTzxiaQaPE3mLB_3JQ,
 mdb_engine/indexes/__init__.py,sha256=9QFJ6qo_yD26dZcKyKjj-hhesFpaomBt-mWTtYTQvqc,613
 mdb_engine/indexes/helpers.py,sha256=tJHqDm18jKLrW-P2ofmnUnaf4_-V5xDLjqP_WU8W9MM,4190
 mdb_engine/indexes/manager.py,sha256=ekrYBfKD-GOBpZMjXIZWSQ7UPLgrD5BINYzVteWkSI8,32508
-mdb_engine/memory/README.md,sha256=Xa7pYut4zgZyRcb2TALcucMVAHCAu9uNGBKSwE7stY8,14764
-mdb_engine/memory/__init__.py,sha256=e4kAYgxd_-WAH8GovTwjEBO9hvASu_kXEupMgksAL-U,1008
-mdb_engine/memory/service.py,sha256=huWIjHAsV-g_Cs9djRkd8v5ZgnqiXqtNEbNjAgMfzs4,28846
+mdb_engine/memory/README.md,sha256=3NqI-Sm8Cy-4lsU1wAWxSg92XpRFK19OfDU_dLo3go0,20581
+mdb_engine/memory/__init__.py,sha256=VEB8PuNBB6q1mSlIYXv9xWt14YmxdiSV5D9hrgmMW94,1328
+mdb_engine/memory/base.py,sha256=bI1Rl14mEAsRSMKe8_3jxzrs-N8LGdYWPwXXRziRDLs,5759
+mdb_engine/memory/service.py,sha256=9uReFG5FaTIs7Fl6Kz7sXES4Uj_4ao7bgcfs32Nvd9U,37164
 mdb_engine/observability/README.md,sha256=CMgQaC1H8ESmCitfbhJifz6-XoXH_FPNE4MvuZ-oFas,13085
 mdb_engine/observability/__init__.py,sha256=jjLsrW6Gy2ayrbfLrgHsDB61NxWWkYLHwv0q-N3fxjA,1213
 mdb_engine/observability/health.py,sha256=ORjxF_rHYA9vCoxUqel5p0n9g3PLmHsHQn68Q402b6g,9212
@@ -91,9 +92,9 @@ mdb_engine/routing/__init__.py,sha256=reupjHi_RTc2ZBA4AH5XzobAmqy4EQIsfSUcTkFknU
 mdb_engine/routing/websockets.py,sha256=w0m1XMpXKPpPrEBcZNIj8B8PwWeTNrseUZE1P8cipdM,53441
 mdb_engine/utils/__init__.py,sha256=lDxQSGqkV4fVw5TWIk6FA6_eey_ZnEtMY0fir3cpAe8,236
 mdb_engine/utils/mongo.py,sha256=Oqtv4tQdpiiZzrilGLEYQPo8Vmh8WsTQypxQs8Of53s,3369
-mdb_engine-0.7.3.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-mdb_engine-0.7.3.dist-info/METADATA,sha256=3XBbRELougI8lJsaJ1A02SuhIpsv2ojQspD2XidEXbo,18843
-mdb_engine-0.7.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mdb_engine-0.7.3.dist-info/entry_points.txt,sha256=INCbYdFbBzJalwPwxliEzLmPfR57IvQ7RAXG_pn8cL8,48
-mdb_engine-0.7.3.dist-info/top_level.txt,sha256=PH0UEBwTtgkm2vWvC9He_EOMn7hVn_Wg_Jyc0SmeO8k,11
-mdb_engine-0.7.3.dist-info/RECORD,,
+mdb_engine-0.7.4.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+mdb_engine-0.7.4.dist-info/METADATA,sha256=T67AUeMaWC1ybxcQRAbPlYgKv9S5yWOJpWsIGCJVyrI,18843
+mdb_engine-0.7.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mdb_engine-0.7.4.dist-info/entry_points.txt,sha256=INCbYdFbBzJalwPwxliEzLmPfR57IvQ7RAXG_pn8cL8,48
+mdb_engine-0.7.4.dist-info/top_level.txt,sha256=PH0UEBwTtgkm2vWvC9He_EOMn7hVn_Wg_Jyc0SmeO8k,11
+mdb_engine-0.7.4.dist-info/RECORD,,