hebbrix 2.0.0__tar.gz

hebbrix-2.0.0/MANIFEST.in

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

hebbrix-2.0.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: hebbrix
+Version: 2.0.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
+Project-URL: Homepage, https://hebbrix.com
+Project-URL: Documentation, https://docs.hebbrix.com
+Project-URL: Repository, https://github.com/hebbrix/hebbrix-python
+Project-URL: Bug Tracker, https://github.com/hebbrix/hebbrix-python/issues
+Project-URL: API Reference, https://memory-api.livelystone-78e9a45c.centralus.azurecontainerapps.io/docs
+Keywords: ai,memory,agents,llm,chatbot,assistant,ml,reinforcement-learning,knowledge-graph,vector-search,rag,temporal,procedural-memory,working-memory
+Classifier: Development Status :: 5 - Production/Stable
+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
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+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: mypy>=1.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Hebbrix Python SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/hebbrix.svg)](https://pypi.org/project/hebbrix/)
+[![Python versions](https://img.shields.io/pypi/pyversions/hebbrix.svg)](https://pypi.org/project/hebbrix/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Official Python SDK for the Hebbrix api - **the only memory API with Reinforcement Learning**.
+
+## 🚀 Features
+
+- ✅ **Complete API Coverage** - All 50+ endpoints supported
+- ✅ **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
+- ✅ **Type Hints** - Complete type annotations
+- ✅ **Clean API** - Pythonic, intuitive interface
+
+## 📦 Installation
+
+```bash
+pip install hebbrix
+```
+
+## 🔥 Quick Start
+
+```python
+import asyncio
+from hebbrix import MemoryClient
+
+async def main():
+    # Initialize client
+    client = MemoryClient(api_key="mem_sk_your_api_key")
+
+    # Create a collection
+    collection = await client.collections.create(
+        name="My AI Agent",
+        description="Personal memory for my chatbot"
+    )
+
+    # Store a memory
+    memory = await client.memories.create(
+        collection_id=collection["id"],
+        content="User prefers dark mode and loves Python",
+        importance=0.9
+    )
+
+    # Search memories
+    results = await client.search(
+        query="What programming language does user like?",
+        collection_id=collection["id"],
+        limit=5
+    )
+
+    print(results)
+
+    # Close client
+    await client.close()
+
+asyncio.run(main())
+```
+
+## 📚 Complete Documentation
+
+Visit https://docs.hebbrix.com for full documentation.
+
+## 🔗 Links
+
+- **Documentation**: https://docs.hebbrix.com
+- **API Reference**: https://api.hebbrix.com/docs
+- **GitHub**: https://github.com/hebbrix/hebbrix
+- **Examples**: https://github.com/hebbrix/examples
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) for details
+
+---
+
+**Built with ❤️ by the Hebbrix team**

hebbrix-2.0.0/README.md

@@ -0,0 +1,82 @@
+# Hebbrix Python SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/hebbrix.svg)](https://pypi.org/project/hebbrix/)
+[![Python versions](https://img.shields.io/pypi/pyversions/hebbrix.svg)](https://pypi.org/project/hebbrix/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Official Python SDK for the Hebbrix api - **the only memory API with Reinforcement Learning**.
+
+## 🚀 Features
+
+- ✅ **Complete API Coverage** - All 50+ endpoints supported
+- ✅ **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
+- ✅ **Type Hints** - Complete type annotations
+- ✅ **Clean API** - Pythonic, intuitive interface
+
+## 📦 Installation
+
+```bash
+pip install hebbrix
+```
+
+## 🔥 Quick Start
+
+```python
+import asyncio
+from hebbrix import MemoryClient
+
+async def main():
+    # Initialize client
+    client = MemoryClient(api_key="mem_sk_your_api_key")
+
+    # Create a collection
+    collection = await client.collections.create(
+        name="My AI Agent",
+        description="Personal memory for my chatbot"
+    )
+
+    # Store a memory
+    memory = await client.memories.create(
+        collection_id=collection["id"],
+        content="User prefers dark mode and loves Python",
+        importance=0.9
+    )
+
+    # Search memories
+    results = await client.search(
+        query="What programming language does user like?",
+        collection_id=collection["id"],
+        limit=5
+    )
+
+    print(results)
+
+    # Close client
+    await client.close()
+
+asyncio.run(main())
+```
+
+## 📚 Complete Documentation
+
+Visit https://docs.hebbrix.com for full documentation.
+
+## 🔗 Links
+
+- **Documentation**: https://docs.hebbrix.com
+- **API Reference**: https://api.hebbrix.com/docs
+- **GitHub**: https://github.com/hebbrix/hebbrix
+- **Examples**: https://github.com/hebbrix/examples
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) for details
+
+---
+
+**Built with ❤️ by the Hebbrix team**

hebbrix-2.0.0/hebbrix/__init__.py

@@ -0,0 +1,69 @@
+"""
+Hebbrix Python SDK - Advanced Memory API for AI Agents
+
+A modern, async-first Python SDK for the Hebbrix Memory API.
+The only memory API with Reinforcement Learning for AI agents.
+
+Quick Start:
+
+    from hebbrix import MemoryClient, MemoryChat
+
+    # Option 1: Simple 3-line chat integration
+    chat = MemoryChat(api_key="hbx_...")
+    response = chat.send("Remember I love Python!", "user_123")
+    response = chat.send("What language do I like?", "user_123")
+
+    # Option 2: Full async API client
+    async with MemoryClient(api_key="hbx_...") as client:
+        # Create collection
+        collection = await client.collections.create(name="My Agent")
+
+        # Store memory
+        memory = await client.memories.create(
+            collection_id=collection["id"],
+            content="Important information"
+        )
+
+        # Search with hybrid vector + BM25 + graph
+        results = await client.search(query="What was important?", limit=5)
+
+        # AI-powered reasoning over memories
+        answer = await client.reason(query="Explain what I learned")
+
+Features:
+- ✅ Reinforcement Learning for memory optimization
+- ✅ Temporal Knowledge Graphs with bi-temporal model
+- ✅ Procedural Memory (skills and learned behaviors)
+- ✅ Working Memory (short-term context buffer)
+- ✅ Memory Consolidation (automatic compression)
+- ✅ 6-layer Hybrid Search (Vector + BM25 + KG + Decay + AI + RL)
+- ✅ Complete async/await support
+- ✅ Type hints throughout
+"""
+
+__version__ = "2.0.0"
+__author__ = "Hebbrix Team"
+__license__ = "MIT"
+
+from hebbrix.client import MemoryClient
+from hebbrix.chat import MemoryChat
+from hebbrix.exceptions import (
+    HebbrixError,
+    AuthenticationError,
+    ValidationError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+)
+
+
+__all__ = [
+    "MemoryClient",
+    "MemoryChat",
+    "HebbrixError",
+    "AuthenticationError",
+    "ValidationError",
+    "NotFoundError",
+    "RateLimitError",
+    "ServerError",
+]

hebbrix-2.0.0/hebbrix/chat.py

@@ -0,0 +1,349 @@
+"""
+Hebbrix Chat Wrapper - 3-Line Integration
+
+The easiest way to add memory-powered conversations to your application.
+
+Example:
+    from hebbrix import MemoryChat
+
+    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 hebbrix.client import MemoryClient
+
+
+class MemoryChat:
+    """
+    Simple chat interface with automatic memory integration.
+
+    This is the easiest way to use Hebbrix - just 3 lines of code!
+
+    Features:
+    - Automatic memory retrieval
+    - User profile injection
+    - Session management
+    - RL-powered personalization
+    - OpenAI-compatible responses
+
+    Example:
+        ```python
+        from hebbrix import MemoryChat
+
+        # Line 1: Initialize
+        chat = MemoryChat(api_key="mem_sk_...")
+
+        # Line 2: Send message
+        response = chat.send("Hi, remember that I love pizza?", "user_123")
+
+        # Line 3: Get response with memory
+        response = chat.send("What's my favorite food?", "user_123")
+        print(response)  # "Your favorite food is pizza!"
+        ```
+
+    Args:
+        api_key: Hebbrix API key
+        base_url: API base URL (default: https://api.hebbrix.com)
+        model: LLM model to use (default: gpt-4o-mini)
+        auto_memory: Enable automatic memory retrieval (default: True)
+        auto_profile: Enable user profile injection (default: True)
+        personalization: Enable RL-powered personalization (default: True)
+        learning: Enable RL trajectory logging (default: True)
+        prompt_strategy: Prompt template strategy (default: "default")
+        memory_limit: Max memories to retrieve per message (default: 10)
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "http://localhost:8000",
+        model: str = "gpt-4o-mini",
+        auto_memory: bool = True,
+        auto_profile: bool = True,
+        personalization: bool = True,
+        learning: bool = True,
+        prompt_strategy: str = "default",
+        memory_limit: int = 10,
+    ):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+        self.prompt_strategy = prompt_strategy
+        self.memory_limit = memory_limit
+
+        # Feature configuration
+        self.features = {
+            "memory": auto_memory,
+            "user_profile": auto_profile,
+            "personalization": personalization,
+            "learning": learning,
+        }
+
+        # Also create full client for advanced operations
+        self.client = MemoryClient(api_key=api_key, base_url=base_url)
+
+    def send(
+        self,
+        message: str,
+        session_id: str,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+    ) -> str:
+        """
+        Send a message and get a response with automatic memory integration.
+
+        This is the main method - just call it and Hebbrix handles everything!
+
+        Args:
+            message: Your message
+            session_id: Session identifier (user ID or conversation ID)
+            temperature: Response randomness (0-2, default: 0.7)
+            max_tokens: Maximum response length (default: None)
+
+        Returns:
+            Assistant's response as a string
+
+        Example:
+            response = chat.send("What did I tell you earlier?", "user_123")
+        """
+        url = f"{self.base_url}/v1/chat/completions"
+
+        payload = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": message}],
+            "session_id": session_id,
+            "features": self.features,
+            "prompt_strategy": self.prompt_strategy,
+            "memory_limit": self.memory_limit,
+            "temperature": temperature,
+        }
+
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        response = requests.post(url, json=payload, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        return data["choices"][0]["message"]["content"]
+
+    def send_with_context(
+        self,
+        message: str,
+        session_id: str,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        Send a message and get full response with memory context.
+
+        Use this when you want to see which memories were used.
+
+        Args:
+            message: Your message
+            session_id: Session identifier
+            temperature: Response randomness (0-2, default: 0.7)
+            max_tokens: Maximum response length (default: None)
+
+        Returns:
+            Full response dict with memory context
+
+        Example:
+            result = chat.send_with_context("What's my name?", "user_123")
+            print(result["message"])  # Assistant's response
+            print(result["memory_context"])  # Which memories were used
+        """
+        url = f"{self.base_url}/v1/chat/completions"
+
+        payload = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": message}],
+            "session_id": session_id,
+            "features": self.features,
+            "prompt_strategy": self.prompt_strategy,
+            "memory_limit": self.memory_limit,
+            "temperature": temperature,
+        }
+
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        response = requests.post(url, json=payload, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+
+        return {
+            "message": data["choices"][0]["message"]["content"],
+            "memory_context": data["memory_context"],
+            "usage": data["usage"],
+            "model": data["model"],
+        }
+
+    def configure_features(
+        self,
+        auto_memory: Optional[bool] = None,
+        auto_profile: Optional[bool] = None,
+        personalization: Optional[bool] = None,
+        learning: Optional[bool] = None,
+    ) -> None:
+        """
+        Configure features on the fly.
+
+        Args:
+            auto_memory: Enable/disable automatic memory retrieval
+            auto_profile: Enable/disable user profile injection
+            personalization: Enable/disable RL personalization
+            learning: Enable/disable RL learning
+        """
+        if auto_memory is not None:
+            self.features["memory"] = auto_memory
+        if auto_profile is not None:
+            self.features["user_profile"] = auto_profile
+        if personalization is not None:
+            self.features["personalization"] = personalization
+        if learning is not None:
+            self.features["learning"] = learning
+
+    def set_model(self, model: str) -> None:
+        """
+        Change the LLM model.
+
+        Args:
+            model: Model name (e.g., "gpt-4o-mini", "claude-3-sonnet")
+        """
+        self.model = model
+
+    def set_strategy(self, strategy: str) -> None:
+        """
+        Change the prompt strategy.
+
+        Args:
+            strategy: Strategy name ("default", "concise", "detailed")
+        """
+        self.prompt_strategy = strategy
+
+    def list_sessions(self, active_only: bool = True) -> List[Dict[str, Any]]:
+        """
+        List all chat sessions.
+
+        Args:
+            active_only: Only return active sessions
+
+        Returns:
+            List of session dicts
+        """
+        url = f"{self.base_url}/v1/chat/sessions"
+        params = {"active_only": active_only}
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        response = requests.get(url, params=params, headers=headers)
+        response.raise_for_status()
+
+        return response.json()["sessions"]
+
+    def get_session_info(self, session_id: str) -> Dict[str, Any]:
+        """
+        Get information about a specific session.
+
+        Args:
+            session_id: Session identifier
+
+        Returns:
+            Session info and statistics
+        """
+        url = f"{self.base_url}/v1/chat/sessions/{session_id}"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+
+        return response.json()
+
+    def delete_session(self, session_id: str) -> None:
+        """
+        Delete a chat session.
+
+        Args:
+            session_id: Session identifier
+        """
+        url = f"{self.base_url}/v1/chat/sessions/{session_id}"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        response = requests.delete(url, headers=headers)
+        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]:
+        """
+        Add a memory manually.
+
+        Args:
+            content: Memory content
+            collection_id: Collection ID
+            importance: Memory importance (0-1)
+
+        Returns:
+            Created memory dict
+        """
+        return self.client.memories.create(
+            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]]:
+        """
+        Search memories manually.
+
+        Args:
+            query: Search query
+            collection_id: Optional collection filter
+            limit: Number of results
+
+        Returns:
+            List of memory dicts
+        """
+        return self.client.memories.search(
+            query=query,
+            collection_id=collection_id,
+            limit=limit,
+        )["results"]
+
+
+# Convenience function for even simpler usage
+def quick_chat(api_key: str, message: str, session_id: str) -> str:
+    """
+    The absolute simplest way to use Hebbrix - single function call.
+
+    Args:
+        api_key: Hebbrix API key
+        message: Your message
+        session_id: Session identifier
+
+    Returns:
+        Assistant's response
+
+    Example:
+        from hebbrix.chat import quick_chat
+
+        response = quick_chat(
+            api_key="mem_sk_...",
+            message="What's my favorite color?",
+            session_id="user_123"
+        )
+    """
+    chat = MemoryChat(api_key=api_key)
+    return chat.send(message, session_id)