hebbrix 2.1.1__tar.gz → 2.3.0__tar.gz

hebbrix-2.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hebbrix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{hebbrix-2.1.1 → hebbrix-2.3.0}/MANIFEST.in

@@ -1,5 +1,4 @@
 include README.md
 include LICENSE
 include pyproject.toml
-recursive-include hebbrix_sdk *.py
-
+recursive-include hebbrix *.py

{hebbrix-2.1.1 → hebbrix-2.3.0}/PKG-INFO

@@ -1,12 +1,10 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.1.1
+Version: 2.3.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
 Author-email: Hebbrix Team <support@hebbrix.com>
 Maintainer-email: Hebbrix Team <support@hebbrix.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://hebbrix.com
 Project-URL: Documentation, https://docs.hebbrix.com
 Project-URL: Repository, https://github.com/hebbrix/hebbrix-python
@@ -18,7 +16,6 @@ Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Database
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -29,17 +26,18 @@ Classifier: Operating System :: OS Independent
 Classifier: Framework :: AsyncIO
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: requests>=2.31.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
 Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: flake8<6.0.0,>=5.0.4; python_full_version < "3.8.1" and extra == "dev"
+Requires-Dist: flake8>=6.0.0; python_full_version >= "3.8.1" and extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
-Dynamic: author
-Dynamic: home-page
-Dynamic: requires-python
+Requires-Dist: cryptography>=42.0.0; extra == "dev"
+Dynamic: license-file
 
 # Hebbrix Python SDK
 
@@ -51,13 +49,14 @@ Official Python SDK for the Hebbrix api - **the only memory API with Reinforceme
 
 ## 🚀 Features
 
-- ✅ **Complete API Coverage** - All 50+ endpoints supported
+- ✅ **Core API Coverage** - Typed resources for memories, search, and ProofLoop
 - ✅ **Reinforcement Learning** - Train AI agents to optimize memory operations
 - ✅ **Temporal Knowledge Graphs** - Track facts over time with bi-temporal model
 - ✅ **Procedural Memory** - Store and execute learned skills
 - ✅ **Working Memory** - Short-term context buffer for conversations
 - ✅ **Memory Consolidation** - Automatic compression of episodic memories
-- ✅ **Async/Await** - Full async support with httpx
+- ✅ **ProofLoop** - Learn from outcomes with automatic, verifiable evidence receipts
+- ✅ **Sync + Async** - Equivalent core memory and ProofLoop workflows
 - ✅ **Type Hints** - Complete type annotations
 - ✅ **Clean API** - Pythonic, intuitive interface
 
@@ -86,8 +85,11 @@ async def main():
     # Store a memory
     memory = await client.memories.create(
         collection_id=collection["id"],
+        user_id="customer-7",
+        agent_id="support-agent",
         content="User prefers dark mode and loves Python",
-        importance=0.9
+        importance=0.9,
+        wait_for_index=True,
     )
 
     # Search memories
@@ -105,6 +107,47 @@ async def main():
 asyncio.run(main())
 ```
 
+Blocking applications can use the same create/search/ProofLoop fields:
+
+```python
+from hebbrix import SyncMemoryClient
+
+with SyncMemoryClient(api_key="mem_sk_your_api_key") as client:
+    collection = client.collections.create(name="My Agent")
+    client.memories.create(
+        collection_id=collection["id"],
+        user_id="customer-7",
+        content="User prefers concise answers",
+        wait_for_index=True,
+    )
+    results = client.search(
+        "How should answers be formatted?",
+        collection_id=collection["id"],
+        user_id="customer-7",
+    )
+```
+
+## ProofLoop: search → decision → outcome → proof
+
+```python
+search = await client.search_with_proof(
+    "What should the agent do next?",
+    collection_id="collection-42",
+    user_id="customer-7",
+)
+decision = await client.proofloop.decide(
+    policy_key="agent.next_action",
+    candidates=[{"action_key": "act"}, {"action_key": "ask"}],
+    collection_id="collection-42",
+    user_id="customer-7",
+    proof_context=search["proof_context"],
+)
+await client.proofloop.record_outcome(
+    decision["decision_id"], success=True, idempotency_key="run-123-result"
+)
+proof = await client.proofloop.proof(decision["decision_id"])
+```
+
 ## 📚 Complete Documentation
 
 Visit https://docs.hebbrix.com for full documentation.

{hebbrix-2.1.1 → hebbrix-2.3.0}/README.md

@@ -8,13 +8,14 @@ Official Python SDK for the Hebbrix api - **the only memory API with Reinforceme
 
 ## 🚀 Features
 
-- ✅ **Complete API Coverage** - All 50+ endpoints supported
+- ✅ **Core API Coverage** - Typed resources for memories, search, and ProofLoop
 - ✅ **Reinforcement Learning** - Train AI agents to optimize memory operations
 - ✅ **Temporal Knowledge Graphs** - Track facts over time with bi-temporal model
 - ✅ **Procedural Memory** - Store and execute learned skills
 - ✅ **Working Memory** - Short-term context buffer for conversations
 - ✅ **Memory Consolidation** - Automatic compression of episodic memories
-- ✅ **Async/Await** - Full async support with httpx
+- ✅ **ProofLoop** - Learn from outcomes with automatic, verifiable evidence receipts
+- ✅ **Sync + Async** - Equivalent core memory and ProofLoop workflows
 - ✅ **Type Hints** - Complete type annotations
 - ✅ **Clean API** - Pythonic, intuitive interface
 
@@ -43,8 +44,11 @@ async def main():
     # Store a memory
     memory = await client.memories.create(
         collection_id=collection["id"],
+        user_id="customer-7",
+        agent_id="support-agent",
         content="User prefers dark mode and loves Python",
-        importance=0.9
+        importance=0.9,
+        wait_for_index=True,
     )
 
     # Search memories
@@ -62,6 +66,47 @@ async def main():
 asyncio.run(main())
 ```
 
+Blocking applications can use the same create/search/ProofLoop fields:
+
+```python
+from hebbrix import SyncMemoryClient
+
+with SyncMemoryClient(api_key="mem_sk_your_api_key") as client:
+    collection = client.collections.create(name="My Agent")
+    client.memories.create(
+        collection_id=collection["id"],
+        user_id="customer-7",
+        content="User prefers concise answers",
+        wait_for_index=True,
+    )
+    results = client.search(
+        "How should answers be formatted?",
+        collection_id=collection["id"],
+        user_id="customer-7",
+    )
+```
+
+## ProofLoop: search → decision → outcome → proof
+
+```python
+search = await client.search_with_proof(
+    "What should the agent do next?",
+    collection_id="collection-42",
+    user_id="customer-7",
+)
+decision = await client.proofloop.decide(
+    policy_key="agent.next_action",
+    candidates=[{"action_key": "act"}, {"action_key": "ask"}],
+    collection_id="collection-42",
+    user_id="customer-7",
+    proof_context=search["proof_context"],
+)
+await client.proofloop.record_outcome(
+    decision["decision_id"], success=True, idempotency_key="run-123-result"
+)
+proof = await client.proofloop.proof(decision["decision_id"])
+```
+
 ## 📚 Complete Documentation
 
 Visit https://docs.hebbrix.com for full documentation.

{hebbrix-2.1.1 → hebbrix-2.3.0}/hebbrix/__init__.py

@@ -41,24 +41,26 @@ Features:
 - ✅ Type hints throughout
 """
 
-__version__ = "2.1.1"
+__version__ = "2.3.0"
 __author__ = "Hebbrix Team"
 __license__ = "MIT"
 
-from hebbrix.client import MemoryClient
 from hebbrix.chat import MemoryChat
+from hebbrix.client import MemoryClient
 from hebbrix.exceptions import (
-    HebbrixError,
     AuthenticationError,
-    ValidationError,
+    HebbrixError,
     NotFoundError,
     RateLimitError,
     ServerError,
+    ValidationError,
 )
-
+from hebbrix.models import EvidenceClaim, GroundingReceipt, SearchSafetyEnvelope
+from hebbrix.sync_client import SyncMemoryClient
 
 __all__ = [
     "MemoryClient",
+    "SyncMemoryClient",
     "MemoryChat",
     "HebbrixError",
     "AuthenticationError",
@@ -66,4 +68,7 @@ __all__ = [
     "NotFoundError",
     "RateLimitError",
     "ServerError",
+    "GroundingReceipt",
+    "EvidenceClaim",
+    "SearchSafetyEnvelope",
 ]

{hebbrix-2.1.1 → hebbrix-2.3.0}/hebbrix/client.py

@@ -8,14 +8,30 @@ 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)
+from hebbrix.exceptions import (
+    AuthenticationError,
+    HebbrixError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+from hebbrix.resources import (
+    AuthResource,
+    CollectionsResource,
+    ConsolidationResource,
+    CorrectionsResource,
+    MemoriesResource,
+    MemoryJobsResource,
+    MemoryToolsResource,
+    ProceduralResource,
+    ProofLoopResource,
+    RLResource,
+    SearchResource,
+    TemporalResource,
+    WorkingMemoryResource,
+    WorldModelResource,
+)
 
 
 class MemoryClient:
@@ -59,7 +75,10 @@ class MemoryClient:
         self.auth = AuthResource(self)
         self.collections = CollectionsResource(self)
         self.memories = MemoriesResource(self)
+        self.memory_jobs = MemoryJobsResource(self)
+        self.corrections = CorrectionsResource(self)
         self.search_resource = SearchResource(self)
+        self.proofloop = ProofLoopResource(self)
         self.rl = RLResource(self)
         self.procedural = ProceduralResource(self)
         self.temporal = TemporalResource(self)
@@ -72,7 +91,7 @@ class MemoryClient:
         """Get request headers."""
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": "hebbrix-python/2.0.0",
+            "User-Agent": "hebbrix-python/2.3.0",
         }
 
         if self.api_key:
@@ -160,6 +179,14 @@ class MemoryClient:
         limit: int = 10,
         search_type: str = "hybrid",
         filters: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+        fast: Optional[bool] = None,
+        threshold: Optional[float] = None,
+        include_low_confidence: bool = False,
+        group_by_source: bool = True,
+        debug: bool = False,
     ) -> List[Dict[str, Any]]:
         """
         Search memories.
@@ -180,6 +207,48 @@ class MemoryClient:
             limit=limit,
             search_type=search_type,
             filters=filters or {},
+            user_id=user_id,
+            agent_id=agent_id,
+            run_id=run_id,
+            fast=fast,
+            threshold=threshold,
+            include_low_confidence=include_low_confidence,
+            group_by_source=group_by_source,
+            debug=debug,
+        )
+
+    async def search_with_proof(
+        self,
+        query: str,
+        collection_id: Optional[str] = None,
+        limit: int = 10,
+        search_type: str = "hybrid",
+        filters: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+        fast: Optional[bool] = None,
+        threshold: Optional[float] = None,
+        include_low_confidence: bool = False,
+        group_by_source: bool = True,
+        debug: bool = False,
+    ) -> Dict[str, Any]:
+        """Search and return both results and the automatic ProofLoop context."""
+
+        return await self.search_resource.search_with_proof(
+            query=query,
+            collection_id=collection_id,
+            limit=limit,
+            search_type=search_type,
+            filters=filters or {},
+            user_id=user_id,
+            agent_id=agent_id,
+            run_id=run_id,
+            fast=fast,
+            threshold=threshold,
+            include_low_confidence=include_low_confidence,
+            group_by_source=group_by_source,
+            debug=debug,
         )
 
     async def reason(
@@ -188,6 +257,10 @@ class MemoryClient:
         collection_id: Optional[str] = None,
         provider: Optional[str] = None,
         include_steps: bool = False,
+        user_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+        facets: Optional[List[str]] = None,
     ) -> Dict[str, Any]:
         """
         Perform reasoning over memories.
@@ -197,6 +270,10 @@ class MemoryClient:
             collection_id: Optional collection filter
             provider: LLM provider (gemini, openai, anthropic)
             include_steps: Include reasoning steps
+            user_id: End-user isolation scope
+            agent_id: Agent isolation scope
+            run_id: Run isolation scope
+            facets: Optional typed decomposition facets
 
         Returns:
             Reasoning result with answer and sources
@@ -206,6 +283,10 @@ class MemoryClient:
             collection_id=collection_id,
             provider=provider,
             include_steps=include_steps,
+            user_id=user_id,
+            agent_id=agent_id,
+            run_id=run_id,
+            facets=facets,
         )
 
     async def close(self):

hebbrix-2.3.0/hebbrix/models.py

@@ -0,0 +1,40 @@
+"""Public response contracts for evidence-bearing Hebbrix operations."""
+
+from typing import Any, Dict, List, TypedDict
+
+
+class GroundingReceipt(TypedDict, total=False):
+    """Authoritative claim-grounding decision returned by the API."""
+
+    status: str
+    reason: str
+    contract_version: str
+    requested_predicate: str
+    requested_attribute: str
+    subject_anchors: List[str]
+
+
+class EvidenceClaim(TypedDict, total=False):
+    """Claims attributed to one exact memory evidence identifier."""
+
+    memory_id: str
+    claims: Dict[str, Any]
+
+
+class SearchSafetyEnvelope(TypedDict, total=False):
+    """Fail-closed response shared by search and reasoning helpers."""
+
+    query: str
+    results: List[Dict[str, Any]]
+    sources: List[Dict[str, Any]]
+    total: int
+    no_match: bool
+    abstain_recommended: bool
+    query_confidence: float
+    grounding: GroundingReceipt
+    evidence_ids: List[str]
+    evidence_claims: List[EvidenceClaim]
+    safety_contract_version: str
+    degraded: bool
+    sdk_safety_reason: str
+    proof_context: Dict[str, Any]