mdb-engine 0.7.0__tar.gz → 0.7.2__tar.gz

{mdb_engine-0.7.0/mdb_engine.egg-info → mdb_engine-0.7.2}/PKG-INFO

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

{mdb_engine-0.7.0 → mdb_engine-0.7.2}/mdb_engine/__init__.py

@@ -82,19 +82,13 @@ from .repositories import Entity, MongoRepository, Repository, UnitOfWork
 from .utils import clean_mongo_doc, clean_mongo_docs
 
 __version__ = (
-    "0.6.0"  # Secure-by-default WebSocket authentication with encrypted session keys
-    # - NEW: WebSocket session key generation and management
-    # - NEW: Envelope encryption for WebSocket session keys
-    # - NEW: Secure-by-default CSRF protection (csrf_required: true)
-    # - NEW: WebSocketSessionManager with private collection storage
-    # - NEW: Session key endpoint (/auth/websocket-session)
-    # - NEW: Session key integration in login flow
-    # - ENHANCED: WebSocket authentication with session key support
-    # - ENHANCED: CSRF middleware session key validation
-    # - ENHANCED: Multi-app WebSocket routing with session keys
-    # - BACKWARD COMPATIBLE: Cookie-based authentication fallback
-    # - UPDATED: All documentation for secure-by-default approach
-    # - COMPREHENSIVE: Unit and integration tests for session keys
+    "0.7.2"  # Memory service update functionality
+    # - ADDED: Memory service update() method for in-place memory updates
+    # - ADDED: Support for updating memory content and metadata while preserving IDs
+    # - ADDED: Automatic embedding recomputation via Mem0's update method
+    # - ADDED: Comprehensive unit tests for memory update functionality (17 tests)
+    # - ENHANCED: Memory service now uses Mem0's native update method exclusively
+    # - REMOVED: Direct MongoDB update fallback (simplified implementation)
 )
 
 __all__ = [

{mdb_engine-0.7.0 → mdb_engine-0.7.2}/mdb_engine/cli/main.py

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

{mdb_engine-0.7.0 → mdb_engine-0.7.2}/mdb_engine/core/engine.py

@@ -36,6 +36,11 @@ from typing import TYPE_CHECKING, Any, Optional
 from motor.motor_asyncio import AsyncIOMotorClient
 from pymongo.errors import PyMongoError
 
+try:
+    from openai import OpenAIError
+except ImportError:
+    OpenAIError = RuntimeError
+
 if TYPE_CHECKING:
     from fastapi import FastAPI
 
@@ -2672,7 +2677,7 @@ class MongoDBEngine:
                 )
 
         @asynccontextmanager
-        async def lifespan(app: FastAPI):
+        async def lifespan(app: FastAPI):  # noqa: C901
             """Lifespan context manager for parent app."""
             nonlocal mounted_apps, shared_user_pool_initialized
 
@@ -2911,11 +2916,60 @@ class MongoDBEngine:
                     child_app.add_middleware(middleware_class)
                     logger.debug(f"Added AppContextMiddleware to child app '{slug}'")
 
-                    # CRITICAL FIX: Register WebSocket routes on parent app BEFORE mounting
-                    # This ensures WebSocket routes are checked before mounted app routes
-                    # Mounted apps create catch-all routes that intercept /app-slug/* paths
                     await _register_websocket_routes(app, app_manifest_data, slug, path_prefix)
 
+                    memory_config = app_manifest_data.get("memory_config")
+                    if memory_config and memory_config.get("enabled", False):
+                        if engine._service_initializer:  # noqa: SLF001
+                            try:
+                                await engine._service_initializer.initialize_memory_service(  # noqa: SLF001
+                                    slug, memory_config
+                                )
+                                logger.info(
+                                    f"Memory service initialized for mounted app '{slug}' "
+                                    f"in multi-app context"
+                                )
+                            except OpenAIError as e:
+                                logger.warning(
+                                    f"Memory service initialization skipped for mounted app "
+                                    f"'{slug}': OpenAI API error. {e}",
+                                    extra={"app_slug": slug, "error": str(e)},
+                                )
+                            except (
+                                ImportError,
+                                AttributeError,
+                                TypeError,
+                                ValueError,
+                                RuntimeError,
+                                ConnectionError,
+                                OSError,
+                            ) as e:
+                                error_msg = str(e).lower()
+                                error_type = type(e).__name__
+                                is_api_key_error = (
+                                    "api_key" in error_msg
+                                    or "api key" in error_msg
+                                    or "openai" in error_type.lower()
+                                )
+                                if is_api_key_error:
+                                    logger.warning(
+                                        f"Memory service initialization skipped for mounted app "
+                                        f"'{slug}': Missing API key or configuration. {e}",
+                                        extra={"app_slug": slug, "error": str(e)},
+                                    )
+                                else:
+                                    logger.error(
+                                        f"Failed to initialize memory service for mounted app "
+                                        f"'{slug}': {e}",
+                                        exc_info=True,
+                                        extra={"app_slug": slug, "error": str(e)},
+                                    )
+                        else:
+                            logger.warning(
+                                f"Memory service requested for '{slug}' but "
+                                f"service_initializer is not available"
+                            )
+
                     # Mount child app at path prefix (AFTER WebSocket routes are registered)
                     app.mount(path_prefix, child_app)
 

{mdb_engine-0.7.0 → mdb_engine-0.7.2}/mdb_engine/core/service_initialization.py

@@ -26,6 +26,11 @@ from ..observability import get_logger as get_contextual_logger
 logger = logging.getLogger(__name__)
 contextual_logger = get_contextual_logger(__name__)
 
+try:
+    from openai import OpenAIError
+except ImportError:
+    OpenAIError = RuntimeError
+
 
 class ServiceInitializer:
     """
@@ -54,7 +59,9 @@ class ServiceInitializer:
         self._memory_services: dict[str, Any] = {}
         self._websocket_configs: dict[str, dict[str, Any]] = {}
 
-    async def initialize_memory_service(self, slug: str, memory_config: dict[str, Any]) -> None:
+    async def initialize_memory_service(
+        self, slug: str, memory_config: dict[str, Any] | None
+    ) -> None:
         """
         Initialize Mem0 memory service for an app.
 
@@ -63,8 +70,17 @@ class ServiceInitializer:
 
         Args:
             slug: App slug
-            memory_config: Memory configuration from manifest (already validated)
+            memory_config: Memory configuration from manifest (already validated).
+                Can be None or empty dict to skip initialization.
         """
+        # Handle None or empty config
+        if not memory_config:
+            return
+
+        # Check if memory is enabled (must be checked before import)
+        if not memory_config.get("enabled", False):
+            return
+
         # Try to import Memory service (optional dependency)
         try:
             from ..memory import Mem0MemoryService, Mem0MemoryServiceError
@@ -145,12 +161,41 @@ class ServiceInitializer:
                 extra={"app_slug": slug, "error": str(e)},
                 exc_info=True,
             )
-        except (ImportError, AttributeError, TypeError, ValueError) as e:
-            contextual_logger.error(
-                f"Error initializing memory service for app '{slug}': {e}",
+        except OpenAIError as e:
+            contextual_logger.warning(
+                f"Memory service initialization skipped for app '{slug}': "
+                f"OpenAI API error. {e}",
                 extra={"app_slug": slug, "error": str(e)},
-                exc_info=True,
             )
+        except (
+            ImportError,
+            AttributeError,
+            TypeError,
+            ValueError,
+            RuntimeError,
+            ConnectionError,
+            OSError,
+        ) as e:
+            error_msg = str(e).lower()
+            error_type = type(e).__name__
+            is_api_key_error = (
+                "api_key" in error_msg
+                or "api key" in error_msg
+                or "openai" in error_type.lower()
+                or "openai" in error_msg
+            )
+            if is_api_key_error:
+                contextual_logger.warning(
+                    f"Memory service initialization skipped for app '{slug}': "
+                    f"Missing API key or configuration. {e}",
+                    extra={"app_slug": slug, "error": str(e)},
+                )
+            else:
+                contextual_logger.error(
+                    f"Error initializing memory service for app '{slug}': {e}",
+                    extra={"app_slug": slug, "error": str(e)},
+                    exc_info=True,
+                )
 
     async def register_websockets(self, slug: str, websockets_config: dict[str, Any]) -> None:
         """
@@ -330,7 +375,18 @@ class ServiceInitializer:
                         extra={"app_slug": slug},
                     )
                     return None
-            return service
+                return service
+
+            # Service not found - check if it should be initialized but wasn't
+            # This can happen in multi-app context if initialization was missed
+            # Note: We can't do async initialization here, so we just log a warning
+            # The explicit initialization in create_multi_app should handle this
+            contextual_logger.debug(
+                f"Memory service not found for '{slug}' - "
+                f"it may not be initialized yet or memory is disabled",
+                extra={"app_slug": slug},
+            )
+            return None
         except (KeyError, AttributeError, TypeError) as e:
             contextual_logger.error(
                 f"Error retrieving memory service for '{slug}': {e}",

{mdb_engine-0.7.0 → mdb_engine-0.7.2}/mdb_engine/memory/README.md

@@ -181,18 +181,49 @@ memories = await memory_service.get_all(
 
 ### Update Memory
 
-Update existing memories:
+Update existing memories in-place while preserving the original memory ID and creation timestamp:
 
 ```python
-# Update memory
-updated = await memory_service.update(
+# Update memory content and metadata
+updated = memory_service.update(
+    memory_id="memory_123",
+    user_id="user123",
+    memory="Updated memory content",
+    metadata={"updated": True, "category": "technical"}
+)
+
+# Update using messages format
+updated = memory_service.update(
     memory_id="memory_123",
     user_id="user123",
     messages=[{"role": "user", "content": "Updated content"}],
     metadata={"updated": True}
 )
+
+# Update only metadata (content unchanged)
+updated = memory_service.update(
+    memory_id="memory_123",
+    user_id="user123",
+    metadata={"category": "updated"}
+)
+
+# Backward compatibility: using 'data' parameter
+updated = memory_service.update(
+    memory_id="memory_123",
+    user_id="user123",
+    data="Updated content",
+    metadata={"updated": True}
+)
 ```
 
+**Key Features:**
+- **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)
+- **Partial Updates**: Can update content only, metadata only, or both
+
 ### Delete Memory
 
 Remove memories:

{mdb_engine-0.7.0 → mdb_engine-0.7.2}/mdb_engine/memory/service.py

@@ -44,6 +44,20 @@ class Mem0MemoryServiceError(Exception):
 
 
 class Mem0MemoryService:
+    """
+    Production-ready Mem0 Memory Service with MongoDB integration.
+
+    Features:
+    - 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
+
+    All operations go through Mem0's API to ensure proper state management,
+    graph updates, and relationship handling.
+    """
+
     def __init__(
         self,
         mongo_uri: str,
@@ -54,6 +68,9 @@ class Mem0MemoryService:
         if not _check_mem0_available():
             raise Mem0MemoryServiceError("Mem0 not installed. pip install mem0ai")
 
+        if not mongo_uri or not db_name or not app_slug:
+            raise Mem0MemoryServiceError("mongo_uri, db_name, and app_slug are required parameters")
+
         self.mongo_uri = mongo_uri
         self.db_name = db_name
         self.app_slug = app_slug
@@ -461,6 +478,273 @@ class Mem0MemoryService:
         ):
             return False
 
+    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 in-place with production-grade error handling.
+
+        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)
+            memory: New memory content as a string (optional)
+            data: Alternative parameter name for memory content (backward compatibility).
+                  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 to merge with existing metadata (optional).
+                     Merged, not replaced - existing keys are preserved unless overridden.
+            **kwargs: Additional arguments passed to Mem0 operations
+
+        Returns:
+            Updated memory object with same ID, or None if memory not found
+
+        Raises:
+            Mem0MemoryServiceError: If update operation fails
+            ValueError: If memory_id is invalid or empty
+
+        Example:
+            ```python
+            # Update content and metadata
+            updated = memory_service.update(
+                memory_id="04f78986-dfad-46fe-8381-034bbee9a2fc",
+                user_id="user123",
+                memory="I love Python programming",
+                metadata={"category": "technical", "updated": True}
+            )
+
+            # Update only metadata (content unchanged)
+            updated = memory_service.update(
+                memory_id="04f78986-dfad-46fe-8381-034bbee9a2fc",
+                user_id="user123",
+                metadata={"category": "updated"}
+            )
+            ```
+        """
+        # Input validation
+        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 (backward compatibility)
+            normalized_memory = self._normalize_content_input(memory, data, messages)
+            normalized_metadata = self._normalize_metadata_input(metadata, data)
+
+            # Verify memory exists before attempting update
+            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},
+                )
+                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"
+                )
+
+            result = self._update_via_mem0(
+                memory_id=memory_id,
+                user_id=user_id,
+                memory=normalized_memory,
+                metadata=normalized_metadata,
+                **kwargs,
+            )
+
+            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
+
+            logger.info(
+                f"Successfully updated memory {memory_id} using Mem0 update method",
+                extra={
+                    "memory_id": memory_id,
+                    "content_updated": bool(normalized_memory),
+                    "metadata_updated": bool(normalized_metadata),
+                },
+            )
+            return result
+
+        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},
+            )
+            raise Mem0MemoryServiceError(f"Update failed: {e}") from e
+
+    def _normalize_content_input(
+        self,
+        memory: str | None,
+        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:
+            if not isinstance(memory, str):
+                raise TypeError("memory parameter must be a string")
+            return memory.strip() if memory.strip() else None
+
+        # Check data parameter
+        if data:
+            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(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)
+
+        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:
+            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
+
+        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.
+
+        This is the primary update path. Mem0's update method handles:
+        - In-place updates preserving memory ID and created_at timestamp
+        - Automatic embedding recomputation when content changes
+        - Metadata merging
+        - User scoping for security
+
+        Args:
+            memory_id: Memory ID to update
+            user_id: User ID for scoping
+            memory: New memory content (normalized)
+            metadata: Metadata to merge (normalized)
+            **kwargs: Additional arguments passed to Mem0
+
+        Returns:
+            Updated memory dict or None if not found
+
+        Raises:
+            Various exceptions from Mem0 if update fails
+        """
+        # Build update parameters matching Mem0's API
+        # Mem0's update method signature:
+        # update(memory_id, text=None, metadata=None, user_id=None, **kwargs)
+        update_kwargs: dict[str, Any] = {"memory_id": memory_id}
+
+        # Add user_id for scoping (Mem0 supports this)
+        if user_id:
+            update_kwargs["user_id"] = str(user_id)
+
+        # Add text/content if provided
+        # Mem0 uses "text" parameter for content
+        if memory:
+            update_kwargs["text"] = memory
+
+        # Add metadata if provided
+        # Mem0 merges metadata automatically
+        if metadata is not None:
+            update_kwargs["metadata"] = metadata
+
+        # Pass through any additional kwargs
+        update_kwargs.update(kwargs)
+
+        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,
+            },
+        )
+
+        # Call Mem0's update method directly
+        # This handles all the complexity: embedding recomputation, ID preservation, etc.
+        result = self.memory.update(**update_kwargs)
+
+        # Normalize result format
+        # Mem0 may return dict, list, or other formats
+        if isinstance(result, dict):
+            return result
+        elif isinstance(result, list) and len(result) > 0:
+            # If list, return first item
+            return result[0] if isinstance(result[0], dict) else None
+        else:
+            # If result is None or unexpected format, return None to trigger fallback
+            logger.debug(
+                f"Mem0 update returned unexpected format: {type(result)}",
+                extra={"memory_id": memory_id},
+            )
+            return None
+
     def _normalize_result(self, result: Any) -> list[dict[str, Any]]:
         """Normalize Mem0's return type (dict vs list)."""
         if result is None:

{mdb_engine-0.7.0 → mdb_engine-0.7.2/mdb_engine.egg-info}/PKG-INFO

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

{mdb_engine-0.7.0 → mdb_engine-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mdb-engine"
-version = "0.7.0"
+version = "0.7.2"
 description = "MongoDB Engine"
 readme = "README.md"
 requires-python = ">=3.10"

{mdb_engine-0.7.0 → mdb_engine-0.7.2}/setup.py

@@ -14,7 +14,7 @@ if readme_file.exists():
 
 setup(
     name="mdb-engine",
-    version="0.7.0",
+    version="0.7.2",
     description="MongoDB Engine",
     long_description=long_description,
     long_description_content_type="text/markdown",