v0.5.2

.github/workflows/regression.yml

@@ -88,18 +88,12 @@ jobs:
         run: |
           pip install -e ".[dev,test]"
 
-      # - name: Install Docker
-      #   run: |
-      #     curl -fsSL https://get.docker.com -o get-docker.sh
-      #     sudo sh get-docker.sh
-
-
       - name: Deploy SeekDB (OceanBase)
         run: |
           # Remove existing container if it exists
           sudo docker rm -f seekdb 2>/dev/null || true
           # Start SeekDB container
-          sudo docker run -d -p 10001:2881 --name seekdb oceanbase/seekdb
+          sudo docker run -d -p 10001:2881 -e MEMORY_LIMIT=4G -e LOG_DISK_SIZE=4G -e DATAFILE_SIZE=4G -e DATAFILE_NEXT=4G -e DATAFILE_MAXSIZE=100G --name seekdb oceanbase/seekdb
           # Wait for database to be ready
           echo "Waiting for SeekDB to be ready..."
           timeout=60
@@ -149,6 +143,7 @@ jobs:
           sed -i 's|^GRAPH_STORE_PASSWORD=.*|GRAPH_STORE_PASSWORD=|' .env
           sed -i "s|^LLM_API_KEY=.*|LLM_API_KEY=${SILICONFLOW_CN_API_KEY}|" .env
           sed -i "s|^EMBEDDING_API_KEY=.*|EMBEDDING_API_KEY=${QWEN_API_KEY}|" .env
+          sed -i "s|^POWERMEM_SERVER_API_KEYS=.*|POWERMEM_SERVER_API_KEYS=key1,key2,key3|" .env
 
       - name: Run regression tests
         env:

examples/langchain/requirements.txt

@@ -2,7 +2,7 @@
 # Install with: pip install -r requirements.txt
 
 # Core dependencies
-powermem>=0.5.0
+powermem>=0.5.1
 python-dotenv>=1.0.0
 
 openai>=1.109.1,<3.0.0

examples/langgraph/requirements.txt

@@ -2,7 +2,7 @@
 # Install with: pip install -r requirements.txt
 
 # Core dependencies
-powermem>=0.5.0
+powermem>=0.5.1
 python-dotenv>=1.0.0
 
 # LangGraph and LangChain dependencies

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "powermem"
-version = "0.5.0"
+version = "0.5.1"
 description = "Intelligent Memory System - Persistent memory layer for LLM applications"
 readme = "README.md"
 license = {text = "Apache-2.0"}

src/powermem/core/audit.py

@@ -92,7 +92,7 @@ def log_event(
                 "user_id": user_id,
                 "agent_id": agent_id,
                 "details": details,
-                "version": "0.5.0",
+                "version": "0.5.1",
             }
 
             # Log to file

src/powermem/core/telemetry.py

@@ -82,7 +82,7 @@ def capture_event(
                 "user_id": user_id,
                 "agent_id": agent_id,
                 "timestamp": get_current_datetime().isoformat(),
-                "version": "0.5.0",
+                "version": "0.5.1",
             }
 
             self.events.append(event)
@@ -182,7 +182,7 @@ def set_user_properties(self, user_id: str, properties: Dict[str, Any]) -> None:
                 "properties": properties,
                 "user_id": user_id,
                 "timestamp": get_current_datetime().isoformat(),
-                "version": "0.5.0",
+                "version": "0.5.1",
             }
 
             self.events.append(event)

src/powermem/prompts/intelligent_memory_prompts.py

@@ -25,6 +25,7 @@
 2. COMPLETE: Extract self-contained facts with who/what/when/where when available.
 3. SEPARATE: Extract distinct facts separately, especially when they have different time periods.
 4. INTENTIONS & NEEDS: ALWAYS extract user intentions, needs, and requests even without time information. Examples: "Want to book a doctor appointment", "Need to call someone", "Plan to visit a place".
+5. LANGUAGE: DO NOT translate. Preserve the original language of the source text for each extracted fact. If the input is Chinese, output facts in Chinese; if English, output in English; if mixed-language, keep each fact in the language it appears in.
 
 Examples:
 Input: Hi.
@@ -51,7 +52,7 @@
 - Extract from user/assistant messages only
 - Extract intentions, needs, and requests even without time information
 - If no relevant facts, return empty list
-- Preserve input language
+- Output must preserve the input language (no translation)
 
 Extract facts from the conversation below:"""
 
@@ -87,6 +88,7 @@
 Delete: Only clear contradictions (e.g., "Loves pizza" vs "Dislikes pizza"). Prefer UPDATE for time conflicts.
 
 Important: Use existing IDs only. Keep same ID when updating. Always preserve temporal information.
+LANGUAGE (CRITICAL): Do NOT translate memory text. Keep the same language as the incoming fact(s) and the original memory whenever possible.
 """
 
 # Alias for compatibility

src/powermem/storage/adapter.py

@@ -484,14 +484,13 @@ def get_all_memories(
         if run_id:
             filters["run_id"] = run_id
 
-        # Get memories from vector store with filters (if supported)
-        if filters and hasattr(self.vector_store, 'list'):
-            # Pass filters to vector store's list method for database-level filtering
-            # Request more records to support offset
-            results = self.vector_store.list(filters=filters, limit=limit + offset)
-        else:
-            # Fallback: get all and filter in memory
-            results = self.vector_store.list(limit=limit + offset)
+        results = self.vector_store.list(
+            filters=filters if filters else None,
+            limit=limit,
+            offset=offset,
+            order_by=sort_by,
+            order=order
+        )
 
         # OceanBase returns [memories], SQLite/PGVector return memories directly
         if results and isinstance(results[0], list):
@@ -549,73 +548,7 @@ def get_all_memories(
 
             memories.append(memory)
 
-        # Apply sorting if specified
-        if sort_by:
-            memories = self._sort_memories(memories, sort_by, order)
-
-        # Apply offset and limit
-        return memories[offset:offset + limit]
-
-    def _sort_memories(
-        self,
-        memories: List[Dict[str, Any]],
-        sort_by: str,
-        order: str = "desc"
-    ) -> List[Dict[str, Any]]:
-        """
-        Sort memories by specified field.
-
-        Args:
-            memories: List of memory dictionaries
-            sort_by: Field to sort by. Options: "created_at", "updated_at", "id"
-            order: Sort order. "desc" for descending (default), "asc" for ascending
-
-        Returns:
-            Sorted list of memories
-        """
-        if not memories or not sort_by:
-            return memories
-
-        reverse = (order.lower() == "desc")
-
-        def get_sort_key(memory: Dict[str, Any]) -> Any:
-            """Get the sort key value from memory."""
-            if sort_by == "created_at":
-                created_at = memory.get("created_at")
-                if created_at is None:
-                    return datetime.min if reverse else datetime.max
-                # Handle both datetime objects and ISO format strings
-                if isinstance(created_at, str):
-                    try:
-                        from datetime import datetime as dt
-                        return dt.fromisoformat(created_at.replace('Z', '+00:00'))
-                    except (ValueError, AttributeError):
-                        return datetime.min if reverse else datetime.max
-                return created_at if isinstance(created_at, datetime) else datetime.min
-            elif sort_by == "updated_at":
-                updated_at = memory.get("updated_at")
-                if updated_at is None:
-                    return datetime.min if reverse else datetime.max
-                # Handle both datetime objects and ISO format strings
-                if isinstance(updated_at, str):
-                    try:
-                        from datetime import datetime as dt
-                        return dt.fromisoformat(updated_at.replace('Z', '+00:00'))
-                    except (ValueError, AttributeError):
-                        return datetime.min if reverse else datetime.max
-                return updated_at if isinstance(updated_at, datetime) else datetime.min
-            elif sort_by == "id":
-                return memory.get("id", 0)
-            else:
-                # Unknown sort field, return original order
-                return None
-
-        try:
-            sorted_memories = sorted(memories, key=get_sort_key, reverse=reverse)
-            return sorted_memories
-        except Exception as e:
-            logger.warning(f"Failed to sort memories by {sort_by}: {e}, returning original order")
-            return memories
+        return memories
 
     def clear_memories(
         self,

src/powermem/storage/base.py

@@ -68,8 +68,16 @@ def col_info(self):
         pass
 
     @abstractmethod
-    def list(self, filters=None, limit=None):
-        """List all memories."""
+    def list(self, filters=None, limit=None, offset=None, order_by=None, order="desc"):
+        """List all memories with optional filtering, pagination and sorting.
+
+        Args:
+            filters: Optional filters to apply
+            limit: Maximum number of results to return
+            offset: Number of results to skip
+            order_by: Field to sort by (e.g., "created_at", "updated_at", "id")
+            order: Sort order, "desc" for descending or "asc" for ascending
+        """
         pass
 
     @abstractmethod

src/powermem/storage/config/pgvector.py

@@ -129,8 +129,10 @@ def check_auth_and_connection(cls, values):
             return values
         if values.get("connection_string") is not None:
             return values
-        user, password = values.get("user"), values.get("password")
-        host, port = values.get("host"), values.get("port")
+        user = values.get("user") or values.get("POSTGRES_USER")
+        password = values.get("password") or values.get("POSTGRES_PASSWORD")
+        host = values.get("host") or values.get("POSTGRES_HOST")
+        port = values.get("port") or values.get("POSTGRES_PORT")
         if user is not None or password is not None:
             if not user or not password:
                 raise ValueError("Both 'user' and 'password' must be provided.")

src/powermem/storage/oceanbase/oceanbase.py

@@ -477,7 +477,7 @@ def insert(self,
             logger.error(f"Failed to insert vectors into collection '{self.collection_name}': {e}", exc_info=True)
             raise
 
-    def _generate_where_clause(self, filters: Optional[Dict] = None, table = None) -> Optional[List]:
+    def _generate_where_clause(self, filters: Optional[Dict] = None, table = None):
         """
         Generate a properly formatted where clause for OceanBase.
 
@@ -497,7 +497,7 @@ def _generate_where_clause(self, filters: Optional[Dict] = None, table = None) -
             table: SQLAlchemy Table object to use for column references. If None, uses self.table.
 
         Returns:
-            Optional[List]: List of SQLAlchemy ColumnElement objects for where clause.
+            SQLAlchemy ColumnElement or None: A single SQLAlchemy expression for where clause, or None if no filters.
         """
         # Use provided table or fall back to self.table
         if table is None:
@@ -582,7 +582,7 @@ def process_condition(cond):
 
         # Handle complex filters with AND/OR
         result = process_condition(filters)
-        return [result] if result is not None else None
+        return result
 
     def _row_to_model(self, row):
         """
@@ -934,8 +934,8 @@ def _fulltext_search(self, query: str, limit: int = 5, filters: Optional[Dict] =
 
         # Combine FTS condition with filter conditions
         where_conditions = [fts_condition]
-        if filter_where_clause:
-            where_conditions.extend(filter_where_clause)
+        if filter_where_clause is not None:
+            where_conditions.append(filter_where_clause)
 
         # Build custom query to include score field
         try:
@@ -1069,9 +1069,8 @@ def _sparse_search(self, sparse_embedding: Dict[int, float], limit: int = 5, fil
             stmt = select(*columns)
 
             # Add where conditions
-            if filter_where_clause:
-                for condition in filter_where_clause:
-                    stmt = stmt.where(condition)
+            if filter_where_clause is not None:
+                stmt = stmt.where(filter_where_clause)
 
             # Order by score ASC (lower negative_inner_product means higher similarity)
             stmt = stmt.order_by(text('score ASC'))
@@ -1991,7 +1990,8 @@ def col_info(self):
             logger.error(f"Failed to get collection info for '{self.collection_name}': {e}", exc_info=True)
             raise
 
-    def list(self, filters: Optional[Dict] = None, limit: Optional[int] = None):
+    def list(self, filters: Optional[Dict] = None, limit: Optional[int] = None,
+             offset: Optional[int] = None, order_by: Optional[str] = None, order: str = "desc"):
         """List all memories."""
         try:
             table = Table(self.collection_name, self.obvector.metadata_obj, autoload_with=self.obvector.engine)
@@ -2000,18 +2000,38 @@ def list(self, filters: Optional[Dict] = None, limit: Optional[int] = None):
             where_clause = self._generate_where_clause(filters, table=table)
 
             # Build output column name list
-            output_columns = self._get_standard_column_names(include_vector_field=True)
+            output_columns_names = self._get_standard_column_names(include_vector_field=True)
+
+            # Build select statement with columns
+            output_columns = [table.c[col_name] for col_name in output_columns_names if col_name in table.c]
+            stmt = select(*output_columns)
+
+            # Apply WHERE clause
+            if where_clause is not None:
+                stmt = stmt.where(where_clause)
+
+            # Apply ORDER BY clause for sorting
+            if order_by:
+                if order_by in table.c:
+                    order_column = table.c[order_by]
+                    if order.lower() == "desc":
+                        stmt = stmt.order_by(order_column.desc())
+                    else:
+                        stmt = stmt.order_by(order_column.asc())
+
+            # Apply OFFSET and LIMIT for pagination
+            if offset is not None:
+                stmt = stmt.offset(offset)
+            if limit is not None:
+                stmt = stmt.limit(limit)
 
-            # Get all records
-            results = self.obvector.get(
-                table_name=self.collection_name,
-                ids=None,
-                output_column_name=output_columns,
-                where_clause=where_clause
-            )
+            # Execute query
+            with self.obvector.engine.connect() as conn:
+                results = conn.execute(stmt)
+                rows = results.fetchall()
 
             memories = []
-            for row in results.fetchall():
+            for row in rows:
                 parsed = self._parse_row_to_dict(row, include_vector=True, extract_score=False)
 
                 memories.append(self._create_output_data(
@@ -2021,9 +2041,6 @@ def list(self, filters: Optional[Dict] = None, limit: Optional[int] = None):
                     parsed["metadata"]
                 ))
 
-            if limit:
-                memories = memories[:limit]
-
             logger.debug(f"Successfully listed {len(memories)} memories from collection '{self.collection_name}'")
             return [memories]