hebbrix 2.0.1__tar.gz → 2.0.3__tar.gz

{hebbrix-2.0.1 → hebbrix-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.0.1
+Version: 2.0.3
 Summary: Advanced Memory API for AI Agents with Reinforcement Learning - 3-line integration
 Home-page: https://github.com/hebbrix/hebbrix-python
 Author: Hebbrix Team

{hebbrix-2.0.1 → hebbrix-2.0.3}/hebbrix/__init__.py

@@ -41,7 +41,7 @@ Features:
 - ✅ Type hints throughout
 """
 
-__version__ = "2.0.0"
+__version__ = "2.0.3"
 __author__ = "Hebbrix Team"
 __license__ = "MIT"
 

{hebbrix-2.0.1 → hebbrix-2.0.3}/hebbrix/chat.py

@@ -9,9 +9,10 @@ Example:
     chat = MemoryChat(api_key="mem_sk_...")
     response = chat.send("What's my favorite food?", session_id="user_123")
 """
-from typing import Optional, Dict, Any, List
-import requests
 
+from typing import Any, Dict, List, Optional
+
+import requests
 from hebbrix.client import MemoryClient
 
 
@@ -53,6 +54,7 @@ class MemoryChat:
         learning: Enable RL trajectory logging (default: True)
         prompt_strategy: Prompt template strategy (default: "default")
         memory_limit: Max memories to retrieve per message (default: 10)
+        source: Collection source ("app" or "api") for data isolation. Sent as X-Hebbrix-Source header.
     """
 
     def __init__(
@@ -66,12 +68,14 @@ class MemoryChat:
         learning: bool = True,
         prompt_strategy: str = "default",
         memory_limit: int = 10,
+        source: Optional[str] = None,
     ):
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
         self.model = model
         self.prompt_strategy = prompt_strategy
         self.memory_limit = memory_limit
+        self.source = source
 
         # Feature configuration
         self.features = {
@@ -82,7 +86,7 @@ class MemoryChat:
         }
 
         # Also create full client for advanced operations
-        self.client = MemoryClient(api_key=api_key, base_url=base_url)
+        self.client = MemoryClient(api_key=api_key, base_url=base_url, source=source)
 
     def send(
         self,
@@ -127,6 +131,8 @@ class MemoryChat:
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json",
         }
+        if self.source:
+            headers["X-Hebbrix-Source"] = self.source
 
         response = requests.post(url, json=payload, headers=headers)
         response.raise_for_status()
@@ -179,6 +185,8 @@ class MemoryChat:
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json",
         }
+        if self.source:
+            headers["X-Hebbrix-Source"] = self.source
 
         response = requests.post(url, json=payload, headers=headers)
         response.raise_for_status()
@@ -286,7 +294,11 @@ class MemoryChat:
         response.raise_for_status()
 
     # Convenience methods for memory operations
-    def add_memory(self, content: str, collection_id: str, importance: float = 0.5) -> Dict[str, Any]:
+    # These use synchronous requests.post() (same as send/send_with_context)
+    # instead of the async MemoryClient to avoid coroutine issues.
+    def add_memory(
+        self, content: str, collection_id: str, importance: float = 0.5
+    ) -> Dict[str, Any]:
         """
         Add a memory manually.
 
@@ -298,13 +310,24 @@ class MemoryChat:
         Returns:
             Created memory dict
         """
-        return self.client.memories.create(
-            content=content,
-            collection_id=collection_id,
-            importance=importance,
-        )
+        url = f"{self.base_url}/v1/memories"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "content": content,
+            "collection_id": collection_id,
+            "importance": importance,
+        }
 
-    def search_memories(self, query: str, collection_id: Optional[str] = None, limit: int = 10) -> List[Dict[str, Any]]:
+        response = requests.post(url, json=payload, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    def search_memories(
+        self, query: str, collection_id: Optional[str] = None, limit: int = 10
+    ) -> List[Dict[str, Any]]:
         """
         Search memories manually.
 
@@ -316,11 +339,21 @@ class MemoryChat:
         Returns:
             List of memory dicts
         """
-        return self.client.memories.search(
-            query=query,
-            collection_id=collection_id,
-            limit=limit,
-        )["results"]
+        url = f"{self.base_url}/v1/search"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload: Dict[str, Any] = {
+            "query": query,
+            "limit": limit,
+        }
+        if collection_id:
+            payload["collection_id"] = collection_id
+
+        response = requests.post(url, json=payload, headers=headers)
+        response.raise_for_status()
+        return response.json().get("results", [])
 
 
 # Convenience function for even simpler usage

{hebbrix-2.0.1 → hebbrix-2.0.3}/hebbrix/client.py

@@ -3,30 +3,19 @@ Hebbrix Client
 
 Main client class for interacting with the Hebbrix api.
 """
-from typing import Optional, Dict, Any, List
-import httpx
 
-from hebbrix.resources import (
-    AuthResource,
-    CollectionsResource,
-    MemoriesResource,
-    SearchResource,
-    RLResource,
-    ProceduralResource,
-    TemporalResource,
-    WorkingMemoryResource,
-    ConsolidationResource,
-    MemoryToolsResource,
-    WorldModelResource,
-)
-from hebbrix.exceptions import (
-    HebbrixError,
-    AuthenticationError,
-    ValidationError,
-    NotFoundError,
-    RateLimitError,
-    ServerError,
-)
+import os
+from typing import Any, Dict, List, Optional
+
+import httpx
+from hebbrix.exceptions import (AuthenticationError, HebbrixError,
+                                NotFoundError, RateLimitError, ServerError,
+                                ValidationError)
+from hebbrix.resources import (AuthResource, CollectionsResource,
+                               ConsolidationResource, MemoriesResource,
+                               MemoryToolsResource, ProceduralResource,
+                               RLResource, SearchResource, TemporalResource,
+                               WorkingMemoryResource, WorldModelResource)
 
 
 class MemoryClient:
@@ -37,6 +26,7 @@ class MemoryClient:
         api_key: API key for authentication
         base_url: Base URL of the API (default: https://api.hebbrix.com)
         timeout: Request timeout in seconds (default: 30)
+        source: Collection source ("app" or "api") for data isolation. Falls back to HEBBRIX_SOURCE env var.
 
     Example:
         >>> client = MemoryClient(api_key="mem_sk_...")
@@ -51,10 +41,12 @@ class MemoryClient:
         api_key: Optional[str] = None,
         base_url: str = "https://api.hebbrix.com",
         timeout: float = 120.0,
+        source: Optional[str] = None,
     ):
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
         self.timeout = timeout
+        self.source = source or os.getenv("HEBBRIX_SOURCE")
 
         # HTTP client
         self._client = httpx.AsyncClient(
@@ -86,6 +78,9 @@ class MemoryClient:
         if self.api_key:
             headers["Authorization"] = f"Bearer {self.api_key}"
 
+        if self.source:
+            headers["X-Hebbrix-Source"] = self.source
+
         return headers
 
     def _handle_error(self, response: httpx.Response) -> None:

{hebbrix-2.0.1 → hebbrix-2.0.3}/hebbrix/resources.py

@@ -3,7 +3,7 @@ API Resource classes
 
 Each resource class wraps a specific set of API endpoints.
 """
-from typing import Optional, Dict, Any, List, TYPE_CHECKING
+from typing import Optional, Dict, Any, List, AsyncIterator, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from hebbrix.client import MemoryClient
@@ -227,29 +227,94 @@ class MemoriesResource(BaseResource):
             },
         )
 
-    async def list(
+    async def list_page(
         self,
         collection_id: Optional[str] = None,
-        skip: int = 0,
-        limit: int = 100,
-    ) -> List[Dict[str, Any]]:
+        cursor: Optional[str] = None,
+        limit: int = 50,
+    ) -> Dict[str, Any]:
         """
-        List memories.
+        List memories with full pagination metadata.
+
+        Returns the raw cursor-paginated response from the backend so callers
+        can iterate pages explicitly.
 
         Args:
             collection_id: Optional collection filter
-            skip: Number of items to skip
-            limit: Maximum number of items
+            cursor: Opaque cursor from a previous page (None for the first page)
+            limit: Page size (backend max: 100)
 
         Returns:
-            List of memories
+            Dict with keys:
+              - items: List[Dict[str, Any]] — memories in this page
+              - next_cursor: Optional[str] — pass to the next call to continue
+              - has_more: bool — True if more pages exist
+              - total_count: int — total number of memories matching the filter
         """
-        params = {"skip": skip, "limit": limit}
+        params: Dict[str, Any] = {"limit": limit}
         if collection_id:
             params["collection_id"] = collection_id
+        if cursor:
+            params["cursor"] = cursor
 
         return await self.client.get("/v1/memories", params=params)
 
+    async def list(
+        self,
+        collection_id: Optional[str] = None,
+        cursor: Optional[str] = None,
+        limit: int = 50,
+    ) -> List[Dict[str, Any]]:
+        """
+        List memories (single page, items only).
+
+        Back-compat convenience that drops pagination metadata. For
+        page-at-a-time access use `list_page`; for iteration across all
+        pages use `iter_all`.
+
+        Args:
+            collection_id: Optional collection filter
+            cursor: Opaque cursor from a previous page
+            limit: Page size (backend max: 100)
+
+        Returns:
+            List of memory dicts for the requested page
+        """
+        page = await self.list_page(
+            collection_id=collection_id, cursor=cursor, limit=limit
+        )
+        return page.get("items", [])
+
+    async def iter_all(
+        self,
+        collection_id: Optional[str] = None,
+        limit: int = 50,
+    ) -> AsyncIterator[Dict[str, Any]]:
+        """
+        Async-iterate every memory matching the filter, following cursors.
+
+        Example:
+            async for memory in client.memories.iter_all(collection_id="col_x"):
+                print(memory["id"])
+
+        Args:
+            collection_id: Optional collection filter
+            limit: Page size used under the hood (backend max: 100)
+
+        Yields:
+            Memory dicts, one per item, across all pages
+        """
+        cursor: Optional[str] = None
+        while True:
+            page = await self.list_page(
+                collection_id=collection_id, cursor=cursor, limit=limit
+            )
+            for item in page.get("items", []):
+                yield item
+            if not page.get("has_more") or not page.get("next_cursor"):
+                break
+            cursor = page["next_cursor"]
+
     async def get(self, memory_id: str) -> Dict[str, Any]:
         """
         Get a specific memory.

{hebbrix-2.0.1 → hebbrix-2.0.3}/hebbrix.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.0.1
+Version: 2.0.3
 Summary: Advanced Memory API for AI Agents with Reinforcement Learning - 3-line integration
 Home-page: https://github.com/hebbrix/hebbrix-python
 Author: Hebbrix Team

{hebbrix-2.0.1 → hebbrix-2.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hebbrix"
-version = "2.0.1"
+version = "2.0.3"
 description = "Advanced Memory API for AI Agents with Reinforcement Learning - 3-line integration"
 readme = "README.md"
 requires-python = ">=3.8"

{hebbrix-2.0.1 → hebbrix-2.0.3}/setup.py

@@ -9,7 +9,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="hebbrix",
-    version="2.0.0",
+    version="2.0.3",
     author="Hebbrix Team",
     author_email="support@hebbrix.com",
     description="Advanced Memory API for AI Agents with Reinforcement Learning - 3-line integration",