cortexdb-agno 0.1.0__py3-none-any.whl

cortexdb_agno/__init__.py

@@ -0,0 +1,13 @@
+"""CortexDB integration for Agno.
+
+Provides a memory backend and agent tools that allow Agno agents
+to use CortexDB as their long-term memory system.
+"""
+
+from cortexdb_agno.memory import CortexDBMemory
+from cortexdb_agno.tools import CortexDBTools
+
+__all__ = [
+    "CortexDBMemory",
+    "CortexDBTools",
+]

cortexdb_agno/memory.py

@@ -0,0 +1,113 @@
+"""Agno memory backend powered by CortexDB.
+
+Provides a memory implementation compatible with Agno's memory system,
+backed by CortexDB's long-term memory. This enables Agno agents to
+persist and recall knowledge across sessions and conversations.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from cortexdb import Cortex
+
+
+class CortexDBMemory:
+    """Agno memory backend that stores and retrieves context via CortexDB.
+
+    Implements Agno's ``Memory`` interface backed by CortexDB's semantic
+    storage. This enables agents to share knowledge across sessions,
+    remember outcomes from previous runs, and build up persistent
+    context over time.
+
+    Args:
+        client: An initialized CortexDB client instance.
+        scope: The hierarchical scope path for memory isolation.
+
+    Example::
+
+        from cortexdb import Cortex
+        from cortexdb_agno import CortexDBMemory
+
+        client = Cortex("http://localhost:3141")
+        memory = CortexDBMemory(client=client, scope="user:default")
+
+        # Store a memory
+        memory.add("The deployment window is 2-4am UTC on Tuesdays.")
+
+        # Search memories
+        results = memory.search("deployment schedule")
+    """
+
+    def __init__(
+        self,
+        client: Cortex,
+        scope: str = "user:default",
+    ) -> None:
+        """Initialize CortexDBMemory with a CortexDB client.
+
+        Args:
+            client: An initialized CortexDB client instance.
+            scope: The hierarchical scope path for memory isolation.
+        """
+        self._client = client
+        self._scope = scope
+
+    def add(self, content: str, metadata: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        """Store a memory in CortexDB.
+
+        Args:
+            content: The text content to store.
+            metadata: Optional metadata to associate with the memory.
+
+        Returns:
+            The experience response dict from CortexDB.
+        """
+        return self._client.experience(self._scope, text=content)
+
+    def search(self, query: str) -> dict[str, Any]:
+        """Search for relevant memories in CortexDB.
+
+        Args:
+            query: The search query string.
+
+        Returns:
+            A dict with a ``context`` key holding the recalled context block.
+        """
+        result = self._client.recall(self._scope, query=query)
+
+        return {
+            "context": result.get("context_block", "") if result else "",
+        }
+
+    def clear(self) -> dict[str, Any]:
+        """Clear all memories for the current scope.
+
+        Issues a forget command to CortexDB to remove all stored memories.
+
+        Returns:
+            The forget response dict from CortexDB.
+        """
+        return self._client.forget(
+            self._scope,
+            confirm_all=True,
+            cascade="redact_events",
+            reason="Agno memory clear requested",
+        )
+
+    def get_context(self, query: str) -> str:
+        """Retrieve formatted context for an agent prompt.
+
+        Convenience method that fetches relevant memories and formats them
+        as a single context string suitable for injection into an agent's
+        system prompt or message history.
+
+        Args:
+            query: The query to find relevant context for.
+
+        Returns:
+            A formatted string of relevant memories.
+        """
+        result = self._client.recall(self._scope, query=query)
+
+        return result.get("context_block", "") if result else ""

cortexdb_agno/tools.py

@@ -0,0 +1,97 @@
+"""Agno tools for interacting with CortexDB.
+
+Provides a toolkit of tools that Agno agents can use to store, search,
+and forget memories in CortexDB's long-term memory system.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agno.tools import Toolkit
+
+from cortexdb import Cortex
+
+
+class CortexDBTools(Toolkit):
+    """Toolkit that creates Agno-compatible tools for CortexDB operations.
+
+    Provides search, store, and forget tools that can be passed directly
+    to an Agno ``Agent``.
+
+    Args:
+        client: An initialized CortexDB client instance.
+        scope: The hierarchical scope path for memory isolation.
+
+    Example::
+
+        from agno.agent import Agent
+        from cortexdb import Cortex
+        from cortexdb_agno import CortexDBTools
+
+        client = Cortex("https://api-v1.cortexdb.ai", actor="user:app", bearer="v4.public...")
+        toolkit = CortexDBTools(client=client, scope="user:default")
+
+        agent = Agent(
+            name="Research Assistant",
+            tools=[toolkit],
+        )
+    """
+
+    def __init__(
+        self,
+        client: Cortex,
+        scope: str = "user:default",
+    ) -> None:
+        super().__init__(name="cortexdb")
+        self._client = client
+        self._scope = scope
+        self.register(self.search_memory)
+        self.register(self.store_memory)
+        self.register(self.forget_memory)
+
+    def search_memory(self, query: str) -> str:
+        """Search CortexDB for relevant memories and past context.
+
+        Args:
+            query: A natural language query describing what to search for.
+
+        Returns:
+            The retrieved context string from CortexDB.
+        """
+        result = self._client.recall(self._scope, query=query)
+
+        context = result.get("context_block", "") if result else ""
+        if not context:
+            return "No relevant memories found in CortexDB."
+
+        return context
+
+    def store_memory(self, content: str) -> str:
+        """Store information in CortexDB's long-term memory.
+
+        Args:
+            content: The information to store as a memory.
+
+        Returns:
+            A confirmation message.
+        """
+        self._client.experience(self._scope, text=content)
+        return "Memory stored successfully in CortexDB."
+
+    def forget_memory(self, reason: str) -> str:
+        """Forget all memories in this scope from CortexDB.
+
+        Args:
+            reason: The reason for forgetting these memories.
+
+        Returns:
+            A confirmation message.
+        """
+        self._client.forget(
+            self._scope,
+            confirm_all=True,
+            cascade="redact_events",
+            reason=reason,
+        )
+        return f"Memories in scope '{self._scope}' have been forgotten."

cortexdb_agno-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: cortexdb-agno
+Version: 0.1.0
+Summary: Agno integration for CortexDB — long-term memory for AI systems
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: agno>=1.0
+Requires-Dist: cortexdbai>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cortexdb-agno
+
+Agno integration for CortexDB long-term memory.
+
+> **LLM provider note (audit BLK-2):** the canonical example uses
+> `from agno.models.openai import OpenAIChat`. CortexDB itself is
+> LLM-agnostic — Agno picks the model. Swap providers with one line:
+>
+> ```python
+> # OpenAI (default in the docs)
+> from agno.models.openai import OpenAIChat
+> model = OpenAIChat(id="gpt-4o")
+>
+> # Anthropic
+> from agno.models.anthropic import Claude
+> model = Claude(id="claude-sonnet-4-6")
+>
+> # Google
+> from agno.models.google import Gemini
+> model = Gemini(id="gemini-1.5-pro")
+> ```
+>
+> Nothing in `cortexdb-agno` reads `OPENAI_API_KEY`.
+
+## Install
+
+```bash
+pip install cortexdb-agno
+```
+
+## API base URL
+
+Defaults to `https://api-v1.cortexdb.ai` (audit FRI-8). Override with
+`CORTEXDB_API_URL`.

cortexdb_agno-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+cortexdb_agno/__init__.py,sha256=gZHmpM3LLApbwR4ahPNqa1CWNbMoEZkeJ-Jt-OPfhp8,320
+cortexdb_agno/memory.py,sha256=yWHxDKfD5FpFyTU2KtknO7u5TyBB-TsGORqOfVryMb8,3598
+cortexdb_agno/tools.py,sha256=cIr724gb8OV9SGKpy6pStktk2A-JS6nxGns5mWFJH08,2868
+cortexdb_agno-0.1.0.dist-info/METADATA,sha256=HY9qYQw7gYFbT-mUfalJOnww8ulwXoaKXMqHyoEmbx0,1206
+cortexdb_agno-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+cortexdb_agno-0.1.0.dist-info/RECORD,,

cortexdb_agno-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any