cortexdb-agno 0.1.0__tar.gz

cortexdb_agno-0.1.0/.gitignore

@@ -0,0 +1,79 @@
+# Rust
+/target
+**/*.rs.bk
+
+# Environment / secrets
+.env
+.env.local
+.env*.local
+*.pem
+*.key
+.npmrc
+
+# SQLite database
+*.sqlite
+*.sqlite-wal
+*.sqlite-shm
+
+# OS
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Data directories
+cortexdb_data*/
+/data/
+# Per-bench tenant stores (RocksDB + Tantivy + HNSW state; regeneratable per run)
+/data_*/
+# Experimental per-branch stores (not tracked on this branch but left gitignored
+# so checkout from other branches doesn't surface them in git status)
+/event_memory_store/
+/llm_cache/
+
+# Benchmark inputs and per-run outputs (kept local, regenerated each run)
+benchmarks/longmemeval/data/
+benchmarks/longmemeval/server_results/
+benchmarks/longmemeval/fast_results/
+benchmarks/longmemeval/micro_results/
+benchmarks/longmemeval/server_logs/
+benchmarks/longmemeval/*.log
+benchmarks/locomo/locomo_results*.json
+benchmarks/locomo/server_results/
+benchmarks/locomo/*.log
+/answer_out.json
+
+# Local Claude Code state
+.claude/
+.tmp/
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+venv/
+
+# Node
+node_modules/
+dist/
+.next/
+
+# Egg info
+*.egg-info/
+
+# Scratch/debug text files at root
+/*.txt
+/*.log
+
+# Local debug / marketing / private content (not for repo)
+harness/.reports/
+harness_data_*/
+blog/
+sales/
+videos/
+local-instance/

cortexdb_agno-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,34 @@
+# 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/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-0.1.0/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-0.1.0/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/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cortexdb-agno"
+version = "0.1.0"
+description = "Agno integration for CortexDB — long-term memory for AI systems"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+dependencies = [
+    "cortexdbai>=0.1.0",
+    "agno>=1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+]

cortexdb_agno-0.1.0/tests/test_agno.py

@@ -0,0 +1,150 @@
+"""Tests for Agno CortexDB integration.
+
+Validates the CortexDBMemory backend and CortexDBTools toolkit against
+the v1 SDK surface, without requiring a live CortexDB or Agno install.
+"""
+
+from __future__ import annotations
+
+import sys
+import unittest
+from unittest.mock import MagicMock, patch
+
+
+# Build mock modules before importing integration code.
+mock_agno_tools = MagicMock()
+
+
+class _MockToolkit:
+    """Stand-in for agno.tools.Toolkit."""
+
+    def __init__(self, name="", **kwargs):
+        self.name = name
+        self.registered = []
+
+    def register(self, fn):
+        self.registered.append(fn)
+        return fn
+
+
+mock_agno_tools.Toolkit = _MockToolkit
+
+mock_agno = MagicMock()
+mock_agno.tools = mock_agno_tools
+mock_agno.agent = MagicMock()
+
+mock_cortexdb = MagicMock()
+
+with patch.dict(sys.modules, {
+    "agno": mock_agno,
+    "agno.tools": mock_agno_tools,
+    "agno.agent": mock_agno.agent,
+    "cortexdb": mock_cortexdb,
+}):
+    from cortexdb_agno.memory import CortexDBMemory
+    from cortexdb_agno.tools import CortexDBTools
+
+
+class TestCortexDBMemory(unittest.TestCase):
+    """Tests for the CortexDBMemory class."""
+
+    def setUp(self) -> None:
+        self.client = MagicMock()
+        self.memory = CortexDBMemory(
+            client=self.client,
+            scope="user:test",
+        )
+
+    def test_init_stores_config(self) -> None:
+        self.assertIs(self.memory._client, self.client)
+        self.assertEqual(self.memory._scope, "user:test")
+
+    def test_init_defaults(self) -> None:
+        m = CortexDBMemory(client=self.client)
+        self.assertEqual(m._scope, "user:default")
+
+    def test_add_calls_experience(self) -> None:
+        self.memory.add("test content")
+        self.client.experience.assert_called_once_with(
+            "user:test", text="test content",
+        )
+
+    def test_search_calls_recall(self) -> None:
+        self.client.recall.return_value = {"context_block": "result"}
+        results = self.memory.search("query")
+        self.client.recall.assert_called_once_with("user:test", query="query")
+        self.assertEqual(results["context"], "result")
+
+    def test_search_empty(self) -> None:
+        self.client.recall.return_value = {"context_block": ""}
+        results = self.memory.search("nothing")
+        self.assertEqual(results["context"], "")
+
+    def test_clear_calls_forget(self) -> None:
+        self.memory.clear()
+        self.client.forget.assert_called_once_with(
+            "user:test",
+            confirm_all=True,
+            cascade="redact_events",
+            reason="Agno memory clear requested",
+        )
+
+    def test_get_context_returns_string(self) -> None:
+        self.client.recall.return_value = {"context_block": "first second"}
+        context = self.memory.get_context("query")
+        self.assertIn("first", context)
+
+    def test_get_context_empty(self) -> None:
+        self.client.recall.return_value = {"context_block": ""}
+        context = self.memory.get_context("query")
+        self.assertEqual(context, "")
+
+
+class TestCortexDBTools(unittest.TestCase):
+    """Tests for the CortexDBTools toolkit."""
+
+    def setUp(self) -> None:
+        self.client = MagicMock()
+        self.toolkit = CortexDBTools(
+            client=self.client,
+            scope="user:test",
+        )
+
+    def test_registers_three_tools(self) -> None:
+        self.assertEqual(len(self.toolkit.registered), 3)
+
+    def test_search_tool_calls_recall(self) -> None:
+        self.client.recall.return_value = {"context_block": "found"}
+        result = self.toolkit.search_memory("test query")
+        self.client.recall.assert_called_once_with("user:test", query="test query")
+        self.assertIn("found", result)
+
+    def test_search_tool_no_results(self) -> None:
+        self.client.recall.return_value = {"context_block": ""}
+        result = self.toolkit.search_memory("nothing")
+        self.assertIn("No relevant memories", result)
+
+    def test_store_tool_calls_experience(self) -> None:
+        result = self.toolkit.store_memory("important info")
+        self.client.experience.assert_called_once_with(
+            "user:test", text="important info",
+        )
+        self.assertIn("stored successfully", result)
+
+    def test_forget_tool_calls_forget(self) -> None:
+        result = self.toolkit.forget_memory("cleanup")
+        self.client.forget.assert_called_once_with(
+            "user:test",
+            confirm_all=True,
+            cascade="redact_events",
+            reason="cleanup",
+        )
+        self.assertIn("forgotten", result)
+
+    def test_default_config(self) -> None:
+        toolkit = CortexDBTools(client=self.client)
+        self.assertEqual(toolkit._scope, "user:default")
+
+
+if __name__ == "__main__":
+    unittest.main()