cortexdbai 0.3.1__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortexdbai
-Version: 0.3.1
+Version: 0.4.0
 Summary: The Long-Term Memory Layer for AI Systems
 Project-URL: Homepage, https://cortexdb.ai
 Project-URL: Documentation, https://docs.cortexdb.ai
@@ -25,12 +25,83 @@ Requires-Dist: httpx>=0.24
 Requires-Dist: pydantic>=2.0
 Requires-Dist: requests>=2.31
 Requires-Dist: tenacity>=8.0
+Provides-Extra: all-integrations
+Requires-Dist: ag2>=0.4; extra == 'all-integrations'
+Requires-Dist: beeai-framework>=0.1; extra == 'all-integrations'
+Requires-Dist: camel-ai>=0.2; extra == 'all-integrations'
+Requires-Dist: controlflow>=0.11; extra == 'all-integrations'
+Requires-Dist: crewai>=0.80; extra == 'all-integrations'
+Requires-Dist: dspy>=2.0; extra == 'all-integrations'
+Requires-Dist: google-adk>=0.1; extra == 'all-integrations'
+Requires-Dist: httpx>=0.27; extra == 'all-integrations'
+Requires-Dist: instructor>=1.0; extra == 'all-integrations'
+Requires-Dist: langchain-core>=0.3; extra == 'all-integrations'
+Requires-Dist: langgraph-checkpoint>=2.0; extra == 'all-integrations'
+Requires-Dist: letta>=0.1; extra == 'all-integrations'
+Requires-Dist: llama-index-core>=0.11; extra == 'all-integrations'
+Requires-Dist: nemoguardrails>=0.9; extra == 'all-integrations'
+Requires-Dist: openai-agents>=0.1; extra == 'all-integrations'
+Requires-Dist: prefect>=3.0; extra == 'all-integrations'
+Requires-Dist: pydantic-ai>=0.1; extra == 'all-integrations'
+Requires-Dist: smolagents>=1.0; extra == 'all-integrations'
+Requires-Dist: temporalio>=1.7; extra == 'all-integrations'
 Provides-Extra: async
 Requires-Dist: httpx[http2]; extra == 'async'
+Provides-Extra: autogen
+Requires-Dist: ag2>=0.4; extra == 'autogen'
+Provides-Extra: beeai
+Requires-Dist: beeai-framework>=0.1; extra == 'beeai'
+Provides-Extra: camel
+Requires-Dist: camel-ai>=0.2; extra == 'camel'
+Provides-Extra: controlflow
+Requires-Dist: controlflow>=0.11; extra == 'controlflow'
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80; extra == 'crewai'
+Provides-Extra: deepinfra
+Requires-Dist: httpx>=0.27; extra == 'deepinfra'
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: dify
+Provides-Extra: dspy
+Requires-Dist: dspy>=2.0; extra == 'dspy'
+Provides-Extra: fireworks
+Requires-Dist: httpx>=0.27; extra == 'fireworks'
+Provides-Extra: flowise
+Provides-Extra: google-adk
+Requires-Dist: google-adk>=0.1; extra == 'google-adk'
+Provides-Extra: groq
+Requires-Dist: httpx>=0.27; extra == 'groq'
+Provides-Extra: hermes
+Provides-Extra: instructor
+Requires-Dist: instructor>=1.0; extra == 'instructor'
+Requires-Dist: pydantic>=2.0; extra == 'instructor'
+Provides-Extra: langgraph
+Requires-Dist: langchain-core>=0.3; extra == 'langgraph'
+Requires-Dist: langgraph-checkpoint>=2.0; extra == 'langgraph'
+Provides-Extra: letta
+Requires-Dist: letta>=0.1; extra == 'letta'
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.11; extra == 'llamaindex'
+Provides-Extra: nemo-guardrails
+Requires-Dist: nemoguardrails>=0.9; extra == 'nemo-guardrails'
+Provides-Extra: ollama
+Requires-Dist: httpx>=0.27; extra == 'ollama'
+Provides-Extra: openai-agents
+Requires-Dist: openai-agents>=0.1; extra == 'openai-agents'
+Provides-Extra: prefect
+Requires-Dist: prefect>=3.0; extra == 'prefect'
+Provides-Extra: pydanticai
+Requires-Dist: pydantic-ai>=0.1; extra == 'pydanticai'
+Provides-Extra: smolagents
+Requires-Dist: smolagents>=1.0; extra == 'smolagents'
+Provides-Extra: temporal
+Requires-Dist: temporalio>=1.7; extra == 'temporal'
+Provides-Extra: together
+Requires-Dist: httpx>=0.27; extra == 'together'
+Provides-Extra: vllm
+Requires-Dist: httpx>=0.27; extra == 'vllm'
 Description-Content-Type: text/markdown
 
 # CortexDB Python SDK

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

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

cortexdbai-0.4.0/cortexdb/integrations/autogen/__init__.py

@@ -0,0 +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",
+]

cortexdbai-0.4.0/cortexdb/integrations/autogen/agent.py

@@ -0,0 +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",
+        )

cortexdbai-0.4.0/cortexdb/integrations/autogen/tools.py

@@ -0,0 +1,165 @@
+"""AutoGen callable tools for interacting with CortexDB.
+
+Provides factory functions that create CortexDB-backed callables
+suitable for registration with AutoGen's ConversableAgent tool system.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Any, Callable
+
+from cortexdb import Cortex
+
+
+def cortexdb_search_fn(
+    client: Cortex,
+    scope: str = "user:default",
+) -> Callable[..., str]:
+    """Create a search function for use as an AutoGen tool.
+
+    Returns a callable that performs semantic recall over CortexDB's
+    memory store, suitable for registration with an AutoGen agent.
+
+    Args:
+        client: An initialized CortexDB client instance.
+        scope: The hierarchical scope path for memory isolation.
+
+    Returns:
+        A callable function that accepts a ``query`` parameter and
+        returns the recalled context block.
+
+    Example::
+
+        from cortexdb import Cortex
+        from cortexdb.integrations.autogen import cortexdb_search_fn
+
+        client = Cortex("http://localhost:3141")
+        search = cortexdb_search_fn(client, scope="user:default")
+
+        agent.register_for_llm(description="Search memories")(search)
+        user_proxy.register_for_execution()(search)
+    """
+
+    def search(
+        query: Annotated[str, "The search query to find relevant memories."],
+    ) -> str:
+        """Search CortexDB for relevant memories and past context."""
+        result = client.recall(scope, query=query)
+
+        context = result.get("context_block", "") if result else ""
+        if not context:
+            return "No relevant memories found."
+
+        return context
+
+    search.__name__ = "cortexdb_search"
+    search.__doc__ = "Search CortexDB for relevant memories and past context."
+    return search
+
+
+def cortexdb_store_fn(
+    client: Cortex,
+    scope: str = "user:default",
+) -> Callable[..., str]:
+    """Create a store function for use as an AutoGen tool.
+
+    Returns a callable that persists information into CortexDB's
+    long-term memory, suitable for registration with an AutoGen agent.
+
+    Args:
+        client: An initialized CortexDB client instance.
+        scope: The hierarchical scope path for memory isolation.
+
+    Returns:
+        A callable function that accepts a ``content`` parameter and
+        returns a confirmation message.
+    """
+
+    def store(
+        content: Annotated[str, "The content to store as a memory."],
+    ) -> str:
+        """Store information in CortexDB's long-term memory."""
+        client.experience(scope, text=content)
+        return "Memory stored successfully in CortexDB."
+
+    store.__name__ = "cortexdb_store"
+    store.__doc__ = "Store information in CortexDB's long-term memory."
+    return store
+
+
+def cortexdb_forget_fn(
+    client: Cortex,
+    scope: str = "user:default",
+) -> Callable[..., str]:
+    """Create a forget function for use as an AutoGen tool.
+
+    Returns a callable that removes memories from CortexDB, suitable
+    for registration with an AutoGen agent.
+
+    Args:
+        client: An initialized CortexDB client instance.
+        scope: The hierarchical scope path for memory isolation.
+
+    Returns:
+        A callable function that accepts a ``reason`` parameter
+        and returns a confirmation message.
+    """
+
+    def forget(
+        reason: Annotated[str, "The reason for forgetting these memories."],
+    ) -> str:
+        """Forget or remove memories from CortexDB."""
+        client.forget(
+            scope,
+            confirm_all=True,
+            cascade="redact_events",
+            reason=reason,
+        )
+        return f"Memories in scope '{scope}' have been forgotten."
+
+    forget.__name__ = "cortexdb_forget"
+    forget.__doc__ = "Forget or remove memories from CortexDB."
+    return forget
+
+
+def register_cortexdb_tools(
+    agent: Any,
+    executor: Any,
+    client: Cortex,
+    scope: str = "user:default",
+) -> None:
+    """Register all CortexDB tools with an AutoGen agent and executor.
+
+    Convenience function that creates and registers search, store, and
+    forget tools on both the LLM-facing agent and the execution proxy.
+
+    Args:
+        agent: The AutoGen ConversableAgent that will call the tools.
+        executor: The AutoGen agent (typically UserProxyAgent) that
+            executes tool calls.
+        client: An initialized CortexDB client instance.
+        scope: The hierarchical scope path for memory isolation.
+
+    Example::
+
+        from autogen import ConversableAgent, UserProxyAgent
+        from cortexdb import Cortex
+        from cortexdb.integrations.autogen import register_cortexdb_tools
+
+        client = Cortex("http://localhost:3141")
+        assistant = ConversableAgent("assistant", llm_config=llm_config)
+        user_proxy = UserProxyAgent("user_proxy")
+
+        register_cortexdb_tools(assistant, user_proxy, client, scope="user:default")
+    """
+    search = cortexdb_search_fn(client, scope)
+    store = cortexdb_store_fn(client, scope)
+    forget = cortexdb_forget_fn(client, scope)
+
+    for fn, desc in [
+        (search, "Search CortexDB for relevant memories and past context."),
+        (store, "Store information in CortexDB's long-term memory."),
+        (forget, "Forget or remove memories from CortexDB."),
+    ]:
+        agent.register_for_llm(description=desc)(fn)
+        executor.register_for_execution()(fn)

cortexdbai-0.4.0/cortexdb/integrations/beeai/__init__.py

@@ -0,0 +1,15 @@
+"""CortexDB integration for BeeAI (IBM / Linux Foundation).
+
+Provides a memory backend and tool implementations that connect
+BeeAI's agent framework to CortexDB's long-term memory system.
+"""
+
+from cortexdb.integrations.beeai.memory import CortexDBMemory
+from cortexdb.integrations.beeai.tools import CortexDBForgetTool, CortexDBSearchTool, CortexDBStoreTool
+
+__all__ = [
+    "CortexDBMemory",
+    "CortexDBSearchTool",
+    "CortexDBStoreTool",
+    "CortexDBForgetTool",
+]

cortexdbai-0.4.0/cortexdb/integrations/beeai/memory.py

@@ -0,0 +1,142 @@
+"""BeeAI memory backend powered by CortexDB.
+
+Provides a BaseMemory-compatible implementation that allows BeeAI agents
+to persist and retrieve long-term memories through CortexDB's distributed
+memory system.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from cortexdb import Cortex
+
+
+class CortexDBMemory:
+    """BeeAI memory backend that stores and retrieves context via CortexDB.
+
+    Implements a memory interface compatible with BeeAI's agent memory
+    system, backed by CortexDB's semantic storage. This enables BeeAI
+    agents to maintain persistent long-term memory across sessions,
+    with semantic retrieval of relevant past context.
+
+    Args:
+        client: An initialized CortexDB client instance.
+        scope: The hierarchical scope path for memory isolation.
+
+    Example::
+
+        from cortexdb import Cortex
+        from cortexdb.integrations.beeai import CortexDBMemory
+
+        client = Cortex("http://localhost:3141")
+        memory = CortexDBMemory(
+            client=client,
+            scope="user:default",
+        )
+
+        # Add a memory
+        memory.add("The deployment cadence is every two weeks.")
+
+        # Retrieve relevant memories
+        context = memory.recall("deployment schedule")
+    """
+
+    def __init__(
+        self,
+        client: Cortex,
+        scope: str = "user:default",
+    ) -> None:
+        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) -> list[dict[str, Any]]:
+        """Search for relevant memories in CortexDB.
+
+        Performs a semantic search over stored memories, returning
+        results ranked by relevance to the query.
+
+        Args:
+            query: The search query string.
+
+        Returns:
+            A list containing a single result dictionary with a
+            ``"content"`` key, or an empty list if no context was found.
+        """
+        result = self._client.recall(self._scope, query=query)
+
+        context = result.get("context_block", "") if result else ""
+        if context:
+            return [{"content": context}]
+        return []
+
+    def recall(self, query: str) -> str:
+        """Retrieve relevant context as a formatted string.
+
+        Convenience method that performs a recall and returns the
+        context string suitable for injection into an agent's prompt.
+
+        Args:
+            query: The query to search for relevant memories.
+
+        Returns:
+            A string containing relevant memories, or an empty
+            string if no relevant memories are found.
+        """
+        result = self._client.recall(self._scope, query=query)
+        return result.get("context_block", "") if result else ""
+
+    def load(self, query: str) -> dict[str, Any]:
+        """Load memory variables for the current query.
+
+        Returns a dictionary of memory variables that can be injected
+        into an agent's context. Compatible with BeeAI's memory loading
+        pattern.
+
+        Args:
+            query: The current query or input text.
+
+        Returns:
+            A dictionary with a ``"context"`` key containing the
+            retrieved memory text.
+        """
+        context = self.recall(query)
+        return {"context": context}
+
+    def save(self, input_text: str, output_text: str) -> None:
+        """Save a conversation turn to memory.
+
+        Stores both the input and output as a single memory entry
+        for future retrieval.
+
+        Args:
+            input_text: The user's input or query.
+            output_text: The agent's response.
+        """
+        content = f"User: {input_text}\nAssistant: {output_text}"
+        self.add(content)
+
+    def clear(self) -> dict[str, Any]:
+        """Clear all memories for the current scope.
+
+        Removes all stored memories from CortexDB for the configured
+        scope. Returns the forget response dict.
+        """
+        return self._client.forget(
+            self._scope,
+            confirm_all=True,
+            cascade="redact_events",
+            reason="BeeAI memory clear requested",
+        )