hebbrix 2.0.2__tar.gz → 2.1.0__tar.gz

{hebbrix-2.0.2 → hebbrix-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.0.2
+Version: 2.1.0
 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.2 → hebbrix-2.1.0}/hebbrix/__init__.py

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

{hebbrix-2.0.2 → hebbrix-2.1.0}/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()
@@ -288,7 +296,9 @@ class MemoryChat:
     # Convenience methods for memory operations
     # 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]:
+    def add_memory(
+        self, content: str, collection_id: str, importance: float = 0.5
+    ) -> Dict[str, Any]:
         """
         Add a memory manually.
 
@@ -315,7 +325,9 @@ class MemoryChat:
         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]]:
+    def search_memories(
+        self, query: str, collection_id: Optional[str] = None, limit: int = 10
+    ) -> List[Dict[str, Any]]:
         """
         Search memories manually.
 

{hebbrix-2.0.2 → hebbrix-2.1.0}/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.2 → hebbrix-2.1.0}/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
@@ -200,20 +200,41 @@ class MemoriesResource(BaseResource):
         source_type: str = "text",
         source_reference: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        infer: bool = False,
     ) -> Dict[str, Any]:
         """
-        Create a new memory.
+        Create a memory.
+
+        By default (``infer=False``) the content is stored verbatim as a single
+        memory and the response's ``results[0].id`` is that memory's real,
+        immediately-resolvable id — so ``create()`` round-trips with ``get()``.
+
+        Behavior change (SDK 2.1.0): previously ``create()`` implicitly used the
+        server's LLM extract-and-resolve path (``infer=true``), which rewrote the
+        content, could emit zero or several fact rows, and — when the server ran
+        extraction asynchronously — returned a transient job id that ``get()``
+        could not resolve. That transient id is why a create/get round-trip
+        failed. Storing verbatim by default makes the returned id stable.
+
+        Pass ``infer=True`` to opt into fact extraction (``POST /v1/memories``
+        with server-side inference). In that mode ``results`` may contain several
+        extracted-fact ids, or the response may be ``{"job_id": ...}`` if the
+        server extracts asynchronously — poll that job rather than treating it as
+        a memory id.
 
         Args:
             collection_id: Collection ID
             content: Memory content
-            importance: Importance score (0-1)
+            importance: Importance hint (0-1)
             source_type: Type of source
             source_reference: Reference to source
             metadata: Optional metadata
+            infer: When True, extract facts via the LLM pipeline instead of
+                storing ``content`` verbatim. Default False (direct store).
 
         Returns:
-            Created memory
+            Created memory (MemoryAddResponse). With ``infer=False`` (default),
+            ``results[0].id`` is the real, get-able memory id.
         """
         return await self.client.post(
             "/v1/memories",
@@ -224,32 +245,98 @@ class MemoriesResource(BaseResource):
                 "source_type": source_type,
                 "source_reference": source_reference,
                 "metadata": metadata or {},
+                "infer": infer,
             },
         )
 
-    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.2 → hebbrix-2.1.0}/hebbrix.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.0.2
+Version: 2.1.0
 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.2 → hebbrix-2.1.0}/pyproject.toml

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

{hebbrix-2.0.2 → hebbrix-2.1.0}/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.1.0",
     author="Hebbrix Team",
     author_email="support@hebbrix.com",
     description="Advanced Memory API for AI Agents with Reinforcement Learning - 3-line integration",