cortexdbai 0.4.0__tar.gz → 0.4.1__tar.gz

{cortexdbai-0.4.0 → cortexdbai-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortexdbai
-Version: 0.4.0
+Version: 0.4.1
 Summary: The Long-Term Memory Layer for AI Systems
 Project-URL: Homepage, https://cortexdb.ai
 Project-URL: Documentation, https://docs.cortexdb.ai

{cortexdbai-0.4.0 → cortexdbai-0.4.1}/cortexdb/__init__.py

@@ -49,7 +49,7 @@ from cortexdb import v1  # the explicit submodule namespace
 Cortex = V1Client
 AsyncCortex = AsyncV1Client
 
-__version__ = "0.3.2"
+__version__ = "0.4.1"
 __all__ = [
     # Clients (preferred top-level names)
     "Cortex",

{cortexdbai-0.4.0 → cortexdbai-0.4.1}/cortexdb/integrations/autogen/__init__.py

@@ -1,21 +1,21 @@
-"""CortexDB integration for AutoGen.
-
-Provides callable tools and a memory-augmented agent that connect
-AutoGen's multi-agent framework to CortexDB's long-term memory system.
-"""
-
-from cortexdb.integrations.autogen.agent import CortexDBAgent
-from cortexdb.integrations.autogen.tools import (
-    cortexdb_forget_fn,
-    cortexdb_search_fn,
-    cortexdb_store_fn,
-    register_cortexdb_tools,
-)
-
-__all__ = [
-    "CortexDBAgent",
-    "cortexdb_search_fn",
-    "cortexdb_store_fn",
-    "cortexdb_forget_fn",
-    "register_cortexdb_tools",
-]
+"""CortexDB integration for AutoGen.
+
+Provides callable tools and a memory-augmented agent that connect
+AutoGen's multi-agent framework to CortexDB's long-term memory system.
+"""
+
+from cortexdb.integrations.autogen.agent import CortexDBAgent
+from cortexdb.integrations.autogen.tools import (
+    cortexdb_forget_fn,
+    cortexdb_search_fn,
+    cortexdb_store_fn,
+    register_cortexdb_tools,
+)
+
+__all__ = [
+    "CortexDBAgent",
+    "cortexdb_search_fn",
+    "cortexdb_store_fn",
+    "cortexdb_forget_fn",
+    "register_cortexdb_tools",
+]

{cortexdbai-0.4.0 → cortexdbai-0.4.1}/cortexdb/integrations/autogen/agent.py

@@ -1,192 +1,192 @@
-"""AutoGen agent with built-in CortexDB memory.
-
-Provides a ConversableAgent subclass that automatically stores
-conversation turns and retrieves relevant context from CortexDB
-before generating responses.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Optional, Union
-
-from autogen import ConversableAgent
-
-from cortexdb import Cortex
-
-
-class CortexDBAgent(ConversableAgent):
-    """AutoGen ConversableAgent with automatic CortexDB memory integration.
-
-    Extends AutoGen's ConversableAgent to automatically store conversation
-    turns in CortexDB and retrieve relevant past context before generating
-    responses. This enables the agent to maintain long-term memory across
-    conversations and sessions.
-
-    The agent injects retrieved context as a system-level prefix to the
-    conversation, giving the LLM access to relevant memories without
-    modifying the visible chat history.
-
-    Args:
-        name: The agent's name.
-        cortex_client: An initialized CortexDB client instance.
-        scope: The hierarchical scope path for memory isolation.
-        auto_store: Whether to automatically store conversation turns.
-            Defaults to ``True``.
-        auto_recall: Whether to automatically retrieve context before
-            responding. Defaults to ``True``.
-        **kwargs: Additional keyword arguments passed to ConversableAgent.
-
-    Example::
-
-        from cortexdb import Cortex
-        from cortexdb.integrations.autogen import CortexDBAgent
-
-        client = Cortex("http://localhost:3141")
-        agent = CortexDBAgent(
-            name="memory_assistant",
-            cortex_client=client,
-            scope="user:default",
-            llm_config=llm_config,
-            system_message="You are a helpful assistant with long-term memory.",
-        )
-    """
-
-    def __init__(
-        self,
-        name: str,
-        cortex_client: Cortex,
-        scope: str = "user:default",
-        auto_store: bool = True,
-        auto_recall: bool = True,
-        **kwargs: Any,
-    ) -> None:
-        """Initialize CortexDBAgent with memory capabilities.
-
-        Args:
-            name: The agent's name.
-            cortex_client: An initialized CortexDB client instance.
-            scope: The hierarchical scope path for memory isolation.
-            auto_store: Whether to automatically store conversation turns.
-            auto_recall: Whether to automatically retrieve context.
-            **kwargs: Additional keyword arguments passed to ConversableAgent.
-        """
-        super().__init__(name=name, **kwargs)
-        self._cortex_client = cortex_client
-        self._scope = scope
-        self._auto_store = auto_store
-        self._auto_recall = auto_recall
-
-    def generate_reply(
-        self,
-        messages: Optional[list[dict[str, Any]]] = None,
-        sender: Optional[Any] = None,
-        **kwargs: Any,
-    ) -> Union[str, dict[str, Any], None]:
-        """Generate a reply with CortexDB memory augmentation.
-
-        Before generating a reply, retrieves relevant context from CortexDB
-        based on the latest message. After generating, stores the conversation
-        turn for future recall.
-
-        Args:
-            messages: The conversation messages to respond to.
-            sender: The agent that sent the message.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            The generated reply string, a structured reply dict, or None.
-        """
-        if messages and self._auto_recall:
-            latest_message = messages[-1]
-            content = latest_message.get("content", "")
-            if content:
-                context = self._recall_context(str(content))
-                if context:
-                    messages = self._inject_memory_context(messages, context)
-
-        reply = super().generate_reply(messages=messages, sender=sender, **kwargs)
-
-        if reply and self._auto_store and messages:
-            latest_content = messages[-1].get("content", "") if messages else ""
-            reply_text = reply if isinstance(reply, str) else reply.get("content", "")
-            if latest_content and reply_text:
-                self._store_turn(str(latest_content), str(reply_text))
-
-        return reply
-
-    def _recall_context(self, query: str) -> str:
-        """Retrieve relevant context from CortexDB.
-
-        Args:
-            query: The query to search for relevant memories.
-
-        Returns:
-            The context string from CortexDB, or empty string on failure.
-        """
-        try:
-            result = self._cortex_client.recall(
-                self._scope,
-                query=query,
-            )
-        except Exception:
-            return ""
-
-        return result.get("context_block", "") if result else ""
-
-    def _store_turn(self, user_message: str, assistant_reply: str) -> None:
-        """Store a conversation turn in CortexDB.
-
-        Args:
-            user_message: The user's message.
-            assistant_reply: The agent's reply.
-        """
-        content = f"User: {user_message}\nAssistant: {assistant_reply}"
-        try:
-            self._cortex_client.experience(self._scope, text=content)
-        except Exception:
-            pass
-
-    def _inject_memory_context(
-        self,
-        messages: list[dict[str, Any]],
-        context: str,
-    ) -> list[dict[str, Any]]:
-        """Inject retrieved memory context into the message list.
-
-        Prepends a system message containing the retrieved context
-        so the LLM can reference it when generating a response.
-
-        Args:
-            messages: The original conversation messages.
-            context: The retrieved context string from CortexDB.
-
-        Returns:
-            A new message list with the memory context injected.
-        """
-        context_message = {
-            "role": "system",
-            "content": (
-                f"Relevant context from long-term memory:\n\n{context}\n\n"
-                "Use this context to inform your response if relevant."
-            ),
-        }
-
-        augmented = list(messages)
-        augmented.insert(0, context_message)
-        return augmented
-
-    def clear_memory(self) -> dict[str, Any]:
-        """Clear all memories for this agent's scope.
-
-        Removes all stored memories from CortexDB for the configured
-        scope path.
-
-        Returns:
-            The forget response dict from CortexDB.
-        """
-        return self._cortex_client.forget(
-            self._scope,
-            confirm_all=True,
-            cascade="redact_events",
-            reason="AutoGen agent memory clear requested",
-        )
+"""AutoGen agent with built-in CortexDB memory.
+
+Provides a ConversableAgent subclass that automatically stores
+conversation turns and retrieves relevant context from CortexDB
+before generating responses.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional, Union
+
+from autogen import ConversableAgent
+
+from cortexdb import Cortex
+
+
+class CortexDBAgent(ConversableAgent):
+    """AutoGen ConversableAgent with automatic CortexDB memory integration.
+
+    Extends AutoGen's ConversableAgent to automatically store conversation
+    turns in CortexDB and retrieve relevant past context before generating
+    responses. This enables the agent to maintain long-term memory across
+    conversations and sessions.
+
+    The agent injects retrieved context as a system-level prefix to the
+    conversation, giving the LLM access to relevant memories without
+    modifying the visible chat history.
+
+    Args:
+        name: The agent's name.
+        cortex_client: An initialized CortexDB client instance.
+        scope: The hierarchical scope path for memory isolation.
+        auto_store: Whether to automatically store conversation turns.
+            Defaults to ``True``.
+        auto_recall: Whether to automatically retrieve context before
+            responding. Defaults to ``True``.
+        **kwargs: Additional keyword arguments passed to ConversableAgent.
+
+    Example::
+
+        from cortexdb import Cortex
+        from cortexdb.integrations.autogen import CortexDBAgent
+
+        client = Cortex("http://localhost:3141")
+        agent = CortexDBAgent(
+            name="memory_assistant",
+            cortex_client=client,
+            scope="user:default",
+            llm_config=llm_config,
+            system_message="You are a helpful assistant with long-term memory.",
+        )
+    """
+
+    def __init__(
+        self,
+        name: str,
+        cortex_client: Cortex,
+        scope: str = "user:default",
+        auto_store: bool = True,
+        auto_recall: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize CortexDBAgent with memory capabilities.
+
+        Args:
+            name: The agent's name.
+            cortex_client: An initialized CortexDB client instance.
+            scope: The hierarchical scope path for memory isolation.
+            auto_store: Whether to automatically store conversation turns.
+            auto_recall: Whether to automatically retrieve context.
+            **kwargs: Additional keyword arguments passed to ConversableAgent.
+        """
+        super().__init__(name=name, **kwargs)
+        self._cortex_client = cortex_client
+        self._scope = scope
+        self._auto_store = auto_store
+        self._auto_recall = auto_recall
+
+    def generate_reply(
+        self,
+        messages: Optional[list[dict[str, Any]]] = None,
+        sender: Optional[Any] = None,
+        **kwargs: Any,
+    ) -> Union[str, dict[str, Any], None]:
+        """Generate a reply with CortexDB memory augmentation.
+
+        Before generating a reply, retrieves relevant context from CortexDB
+        based on the latest message. After generating, stores the conversation
+        turn for future recall.
+
+        Args:
+            messages: The conversation messages to respond to.
+            sender: The agent that sent the message.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The generated reply string, a structured reply dict, or None.
+        """
+        if messages and self._auto_recall:
+            latest_message = messages[-1]
+            content = latest_message.get("content", "")
+            if content:
+                context = self._recall_context(str(content))
+                if context:
+                    messages = self._inject_memory_context(messages, context)
+
+        reply = super().generate_reply(messages=messages, sender=sender, **kwargs)
+
+        if reply and self._auto_store and messages:
+            latest_content = messages[-1].get("content", "") if messages else ""
+            reply_text = reply if isinstance(reply, str) else reply.get("content", "")
+            if latest_content and reply_text:
+                self._store_turn(str(latest_content), str(reply_text))
+
+        return reply
+
+    def _recall_context(self, query: str) -> str:
+        """Retrieve relevant context from CortexDB.
+
+        Args:
+            query: The query to search for relevant memories.
+
+        Returns:
+            The context string from CortexDB, or empty string on failure.
+        """
+        try:
+            result = self._cortex_client.recall(
+                self._scope,
+                query=query,
+            )
+        except Exception:
+            return ""
+
+        return result.get("context_block", "") if result else ""
+
+    def _store_turn(self, user_message: str, assistant_reply: str) -> None:
+        """Store a conversation turn in CortexDB.
+
+        Args:
+            user_message: The user's message.
+            assistant_reply: The agent's reply.
+        """
+        content = f"User: {user_message}\nAssistant: {assistant_reply}"
+        try:
+            self._cortex_client.experience(self._scope, text=content)
+        except Exception:
+            pass
+
+    def _inject_memory_context(
+        self,
+        messages: list[dict[str, Any]],
+        context: str,
+    ) -> list[dict[str, Any]]:
+        """Inject retrieved memory context into the message list.
+
+        Prepends a system message containing the retrieved context
+        so the LLM can reference it when generating a response.
+
+        Args:
+            messages: The original conversation messages.
+            context: The retrieved context string from CortexDB.
+
+        Returns:
+            A new message list with the memory context injected.
+        """
+        context_message = {
+            "role": "system",
+            "content": (
+                f"Relevant context from long-term memory:\n\n{context}\n\n"
+                "Use this context to inform your response if relevant."
+            ),
+        }
+
+        augmented = list(messages)
+        augmented.insert(0, context_message)
+        return augmented
+
+    def clear_memory(self) -> dict[str, Any]:
+        """Clear all memories for this agent's scope.
+
+        Removes all stored memories from CortexDB for the configured
+        scope path.
+
+        Returns:
+            The forget response dict from CortexDB.
+        """
+        return self._cortex_client.forget(
+            self._scope,
+            confirm_all=True,
+            cascade="redact_events",
+            reason="AutoGen agent memory clear requested",
+        )