hana-ai 1.0.26011600__tar.gz → 1.0.26020500__tar.gz

{hana_ai-1.0.26011600/src/hana_ai.egg-info → hana_ai-1.0.26020500}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hana_ai
-Version: 1.0.26011600
+Version: 1.0.26020500
 Summary: Generative AI Toolkit for SAP HANA Cloud
 Author: SAP
 License: Apache-2.0
@@ -54,4 +54,4 @@ We as members, contributors, and leaders pledge to make participation in our com
 
 ## Licensing
 
-Copyright 2025 SAP SE or an SAP affiliate company and generative-ai-toolkit-for-sap-hana-cloud contributors. Please see our [LICENSE](https://github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud/blob/main/LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud).
+Copyright 2026 SAP SE or an SAP affiliate company and generative-ai-toolkit-for-sap-hana-cloud contributors. Please see our [LICENSE](https://github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud/blob/main/LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud).

{hana_ai-1.0.26011600 → hana_ai-1.0.26020500}/README.md

@@ -29,4 +29,4 @@ We as members, contributors, and leaders pledge to make participation in our com
 
 ## Licensing
 
-Copyright 2025 SAP SE or an SAP affiliate company and generative-ai-toolkit-for-sap-hana-cloud contributors. Please see our [LICENSE](https://github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud/blob/main/LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud).
+Copyright 2026 SAP SE or an SAP affiliate company and generative-ai-toolkit-for-sap-hana-cloud contributors. Please see our [LICENSE](https://github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud/blob/main/LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud).

{hana_ai-1.0.26011600 → hana_ai-1.0.26020500}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hana_ai"
-version = "1.0.26011600"
+version = "1.0.26020500"
 authors = [
     {name = "SAP"}
 ]

{hana_ai-1.0.26011600 → hana_ai-1.0.26020500}/src/hana_ai/__init__.py

@@ -2,4 +2,4 @@
 hana_ai is a Python package for AI/ML related utilities.
 """
 
-__version__ = "1.0.26011600"
+__version__ = "1.0.26020500"

{hana_ai-1.0.26011600 → hana_ai-1.0.26020500}/src/hana_ai/agents/hana_agent/agent_base.py

@@ -18,7 +18,13 @@ class AgentBase(MLBase):
     """
     Discovery Agent for interacting with AI Core services.
     """
-    def __init__(self, connection_context, agent_type):
+    def __init__(self, connection_context, agent_type=None,
+                 schema_name: str = "SYS",
+                 procedure_name: str | None = None,
+                 remote_source_name: str = "HANA_DISCOVERY_AGENT_CREDENTIALS",
+                 knowledge_graph_name: str = "HANA_OBJECTS",
+                 rag_schema_name: str = "SYSTEM",
+                 rag_table_name: str = "RAG"):
         """
         Initialize the AgentBase.
 
@@ -26,16 +32,40 @@ class AgentBase(MLBase):
         ----------
         connection_context : ConnectionContext
             The HANA connection context.
-        agent_type : {"DISCOVERY_AGENT_DEV", "DISCOVERY_AGENT", "DATA_AGENT_DEV", "DATA_AGENT"}
-            The type of agent to be used.
+        agent_type : str, optional
+            Deprecated. Previously restricted to fixed values. If provided and
+            `procedure_name` is not set, it will be used as the `procedure_name`
+            for backward compatibility.
+        schema_name : str, optional
+            Schema for the target procedure. Default is "SYS".
+        procedure_name : str, optional
+            The procedure name to call. If omitted, falls back to `agent_type`.
+        remote_source_name : str, optional
+            The name of the remote source to be used. Default is "HANA_DISCOVERY_AGENT_CREDENTIALS".
+        knowledge_graph_name : str, optional
+            The name of the knowledge graph to be used. Default is "HANA_OBJECTS".
+        rag_schema_name : str, optional
+            The name of the RAG schema to be used. Default is "SYSTEM".
+        rag_table_name : str, optional
+            The name of the RAG table to be used. Default is "RAG".
         """
         super().__init__(connection_context)
         self.conn_context = connection_context
         self.remote_source_name = "HANA_DISCOVERY_AGENT_CREDENTIALS"
         self.pse_name = "AI_CORE_PSE"
-        if agent_type not in {"DISCOVERY_AGENT_DEV", "DISCOVERY_AGENT", "DATA_AGENT_DEV", "DATA_AGENT"}:
-            raise ValueError("Invalid agent_type. Must be one of 'DISCOVERY_AGENT_DEV', 'DISCOVERY_AGENT', 'DATA_AGENT_DEV', 'DATA_AGENT'.")
-        self.agent_type = agent_type
+        # Backward compatibility: if `procedure_name` not given, use `agent_type` as procedure
+        if procedure_name is None and agent_type is not None:
+            logging.getLogger(__name__).warning(
+                "`agent_type` parameter is deprecated. Use schema_name/procedure_name instead."
+            )
+            procedure_name = agent_type
+
+        self.schema_name = schema_name
+        self.procedure_name = procedure_name
+        self.knowledge_graph_name = knowledge_graph_name
+        self.rag_schema_name = rag_schema_name
+        self.rag_table_name = rag_table_name
+        self.remote_source_name = remote_source_name
 
     def drop_remote_source(self, remote_source_name: str, cascade: bool = True):
         """
@@ -178,15 +208,22 @@ class AgentBase(MLBase):
             The result of the query execution.
         """
         config = {
-            "remoteSourceName": self.remote_source_name
+            "remoteSourceName": self.remote_source_name,
+            "knowledgeGraphName": self.knowledge_graph_name,
+            "ragSchemaName": self.rag_schema_name,
+            "ragTableName": self.rag_table_name
         }
         if additional_config:
             config.update(additional_config)
 
+        if not self.procedure_name:
+            raise ValueError("procedure_name must be specified for AgentBase to run()")
+
         sql_query = _call_agent_sql(
             query=query,
             config=config,
-            agent_type=self.agent_type
+            schema_name=self.schema_name,
+            procedure_name=self.procedure_name,
         )
 
         logger.info("Executing Discovery Agent SQL: %s", sql_query)

{hana_ai-1.0.26011600 → hana_ai-1.0.26020500}/src/hana_ai/agents/hana_agent/data_agent.py

@@ -23,7 +23,18 @@ class DataAgent(AgentBase):
     - TRUST ADMIN privilege.
     - CERTIFICATE ADMIN privilege.
     """
-    def __init__(self, connection_context, agent_type="DATA_AGENT_DEV"):
+    def __init__(
+        self,
+        connection_context,
+        agent_type: str = "DATA_AGENT_DEV",
+        *,
+        schema_name: str = "SYS",
+        procedure_name: str | None = None,
+        remote_source_name: str = "HANA_DISCOVERY_AGENT_CREDENTIALS",
+        knowledge_graph_name: str = "HANA_OBJECTS",
+        rag_schema_name: str = "SYSTEM",
+        rag_table_name: str = "RAG",
+    ):
         """
         Initialize the DataAgent.
 
@@ -32,7 +43,15 @@ class DataAgent(AgentBase):
         connection_context : ConnectionContext
             The HANA connection context.
         """
-        super().__init__(connection_context, agent_type=agent_type)
+        super().__init__(
+            connection_context,
+            agent_type=agent_type,
+            schema_name=schema_name,
+            procedure_name=procedure_name,
+            remote_source_name=remote_source_name,
+            knowledge_graph_name=knowledge_graph_name,
+            rag_schema_name=rag_schema_name,
+            rag_table_name=rag_table_name,
+        )
         self.conn_context = connection_context
-        self.remote_source_name = "HANA_DISCOVERY_AGENT_CREDENTIALS"
         self.pse_name = "AI_CORE_PSE"

{hana_ai-1.0.26011600 → hana_ai-1.0.26020500}/src/hana_ai/agents/hana_agent/discovery_agent.py

@@ -23,7 +23,18 @@ class DiscoveryAgent(AgentBase):
     - CERTIFICATE ADMIN privilege.
 
     """
-    def __init__(self, connection_context, agent_type="DISCOVERY_AGENT_DEV"):
+    def __init__(
+        self,
+        connection_context,
+        agent_type: str = "DISCOVERY_AGENT_DEV",
+        *,
+        schema_name: str = "SYS",
+        procedure_name: str | None = None,
+        remote_source_name: str = "HANA_DISCOVERY_AGENT_CREDENTIALS",
+        knowledge_graph_name: str = "HANA_OBJECTS",
+        rag_schema_name: str = "SYSTEM",
+        rag_table_name: str = "RAG",
+    ):
         """
         Initialize the DiscoveryAgent.
 
@@ -32,7 +43,15 @@ class DiscoveryAgent(AgentBase):
         connection_context : ConnectionContext
             The HANA connection context.
         """
-        super().__init__(connection_context, agent_type=agent_type)
+        super().__init__(
+            connection_context,
+            agent_type=agent_type,
+            schema_name=schema_name,
+            procedure_name=procedure_name,
+            remote_source_name=remote_source_name,
+            knowledge_graph_name=knowledge_graph_name,
+            rag_schema_name=rag_schema_name,
+            rag_table_name=rag_table_name,
+        )
         self.conn_context = connection_context
-        self.remote_source_name = "HANA_DISCOVERY_AGENT_CREDENTIALS"
         self.pse_name = "AI_CORE_PSE"

{hana_ai-1.0.26011600 → hana_ai-1.0.26020500}/src/hana_ai/agents/hana_agent/utility.py

@@ -350,9 +350,9 @@ def _drop_certificate(connection_context, certificate_name: str):
     except Exception as exc:
         raise Exception("Failed to drop certificate: %s" % str(exc))
 
-def _call_agent_sql(query: str, config: dict, agent_type: str) -> str:
+def _call_agent_sql(query: str, config: dict, schema_name: str, procedure_name: str) -> str:
     """
-    Create SQL string to call the Discovery Agent procedure.
+    Create SQL string to call an agent procedure.
 
     Parameters
     ----------
@@ -360,13 +360,19 @@ def _call_agent_sql(query: str, config: dict, agent_type: str) -> str:
         The query string.
     config : dict
         The configuration dictionary.
-    agent_type : {"DISCOVERY_AGENT_DEV", "DISCOVERY_AGENT", "DATA_AGENT_DEV", "DATA_AGENT"}
+    schema_name : str
+        The schema name where the procedure resides (e.g., "SYS", "DD_AGENT_ADMIN").
+    procedure_name : str
+        The procedure name to invoke (e.g., "DISCOVERY_AGENT", "DATA_AGENT_CUSTOM").
 
     Returns
     -------
     str
-        The SQL string to call the Discovery/Data Agent procedure.
+        The SQL string to call the specified procedure.
     """
     config_json = json.dumps(config).replace("'", "''")
     query = json.dumps(query).replace("'", "''")
-    return "DO\nBEGIN\nDECLARE output NCLOB;\nCALL SYS.%s('%s', '%s', output);\nselect :output FROM DUMMY;\nEND" % (agent_type, query, config_json)
+    return (
+        "DO\nBEGIN\nDECLARE output NCLOB;\nCALL %s.%s('%s', '%s', output);\nselect :output FROM DUMMY;\nEND"
+        % (schema_name, procedure_name, query, config_json)
+    )

hana_ai-1.0.26020500/src/hana_ai/agents/mem0_hana_agent.py

@@ -0,0 +1,313 @@
+"""
+Mem0-powered HANA RAG Agent.
+
+This agent fully uses the Mem0-like adapter (`Mem0HanaAdapter`) for long-term memory
+on HANA, including optional cross-encoder reranking. It preserves short-term memory
+behavior and tool-driven agent execution similar to `HANAMLRAGAgent`, but routes all
+long-term memory operations (add/search/delete/clear) through the adapter.
+
+Usage highlights:
+- Enable reranking via `Mem0HanaAdapter` (using `PALCrossEncoder` when available).
+- Store conversational summaries into HANA vector store with timestamp metadata.
+- Retrieve relevant memories via adapter search with `top_k`, `threshold`, and `filters`.
+- Optionally skip LLM agent initialization for unit tests (`auto_init_agent=False`).
+
+Note: This class is designed to be drop-in alongside `HANAMLRAGAgent` while using
+Mem0's style of memory flow adapted to HANA.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Any, Optional, Tuple, Union
+import logging
+
+from langchain.agents import Tool, AgentExecutor, create_openai_functions_agent
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, HumanMessagePromptTemplate
+from langchain.schema import SystemMessage, AgentAction, AgentFinish
+from langchain.embeddings.base import Embeddings
+from langchain_core.callbacks.manager import CallbackManagerForChainRun
+from langchain_core.tools import BaseTool
+
+from hana_ml.algorithms.pal.utility import check_pal_function_exist
+
+from hana_ai.mem0.hana_mem0_adapter import SearchResult
+from hana_ai.mem0.memory_manager import Mem0MemoryManager, IngestionRules
+from hana_ai.mem0.memory_classifier import Mem0IngestionClassifier
+from hana_ai.mem0.memory_entity_extractor import Mem0EntityExtractor
+from hana_ai.agents.utilities import _get_user_info
+from hana_ai.vectorstore.embedding_service import HANAVectorEmbeddings
+from hana_ai.vectorstore.pal_cross_encoder import PALCrossEncoder
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class FormatSafeAgentExecutor(AgentExecutor):
+    """An AgentExecutor that formats observations safely."""
+    def _take_next_step(
+        self,
+        name_to_tool_map: Dict[str, BaseTool],
+        color_mapping: Dict[str, str],
+        inputs: Dict[str, str],
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        run_manager: Optional[CallbackManagerForChainRun] = None,
+    ) -> Union[AgentFinish, List[Tuple[AgentAction, str]]]:
+        next_step = super()._take_next_step(
+            name_to_tool_map, color_mapping, inputs, intermediate_steps, run_manager
+        )
+        if isinstance(next_step, list):
+            formatted_steps = []
+            for action, observation in next_step:
+                if isinstance(observation, str):
+                    formatted_obs = [{"type": "text", "text": observation}]
+                    formatted_steps.append((action, formatted_obs))
+                else:
+                    formatted_steps.append((action, observation))
+            return formatted_steps
+        return next_step
+
+
+class Mem0HANARAGAgent:
+    """
+    A chatbot that uses Mem0-style long-term memory on HANA with reranking.
+    """
+    def __init__(
+        self,
+        tools: List[Tool],
+        llm: Any,
+        memory_window: int = 10,
+        rerank_candidates: int = 20,
+        rerank_k: int = 3,
+        score_threshold: float = 0.5,
+        hana_vector_table: Optional[str] = None,
+        drop_existing_hana_vector_table: bool = False,
+        verbose: bool = False,
+        session_id: str = "global_session",
+        _auto_init_agent: bool = True,
+    ) -> None:
+        self.llm = llm
+        self.tools = tools
+        self.memory_window = memory_window
+        self.rerank_candidates = rerank_candidates
+        self.rerank_k = rerank_k
+        self.score_threshold = score_threshold
+        self.verbose = verbose
+        self.session_id = session_id
+        self.drop_existing_hana_vector_table = drop_existing_hana_vector_table
+
+        # Detect HANA connection_context from tools
+        self.hana_connection_context = None
+        for tool in self.tools:
+            if hasattr(tool, 'connection_context'):
+                self.hana_connection_context = tool.connection_context
+                break
+
+        # Prepare embedder only when building adapter locally
+        self.embedding_service: Optional[Embeddings] = None
+
+        # Table naming
+        self.user = ''
+        if hana_vector_table is None and self.hana_connection_context:
+            self.user = _get_user_info(self.hana_connection_context)
+            self.hana_vector_table = f"HANA_AI_CHAT_HISTORY_{self.user}"
+        else:
+            self.hana_vector_table = hana_vector_table or "HANA_AI_CHAT_HISTORY_DEFAULT"
+
+        # Initialize memory manager (internal injection via _adapter for tests kept for BC but discouraged)
+        if not self.hana_connection_context:
+            raise ValueError("HANA connection context is required for Mem0HANARAGAgent")
+        # Initialize embedding service and optional reranker
+        self.embedding_service = HANAVectorEmbeddings(self.hana_connection_context)
+        reranker = None
+        try:
+            if self.hana_connection_context and check_pal_function_exist(self.hana_connection_context, '%PAL_CROSSENCODER%', like=True):
+                reranker = PALCrossEncoder(self.hana_connection_context)
+        except Exception:
+            reranker = None
+
+        ingestion_rules = IngestionRules(
+            enabled=True,
+            min_length=1,
+            max_length=None,
+            allow_tags=None,
+            deny_tags=None,
+        )
+
+        self.memory_manager = Mem0MemoryManager(
+            connection_context=self.hana_connection_context,
+            table_name=self.hana_vector_table,
+            embedder=self.embedding_service,
+            reranker=reranker,
+            architecture="vector",
+            default_ttl_seconds=None,
+            short_term_ttl_seconds=None,
+            partition_defaults={"agent_id": "mem0_hana_agent", "session_id": self.session_id},
+            ingestion_rules=ingestion_rules,
+            auto_classification_enabled=True,
+            auto_entity_extraction_enabled=True,
+            entity_assignment_mode="merge",
+        )
+
+        # Scope manager to current user entity
+        if getattr(self, "user", None):
+            self.memory_manager.set_entity(self.user, "user")
+        try:
+            classifier = Mem0IngestionClassifier(self.llm)
+            self.memory_manager.set_classifier(classifier)
+        except Exception:
+            pass
+        try:
+            extractor = Mem0EntityExtractor(self.llm)
+            self.memory_manager.set_entity_extractor(extractor)
+        except Exception:
+            pass
+
+        # Optionally initialize LLM agent (internal flag for tests only)
+        if _auto_init_agent:
+            self._initialize_agent()
+
+    def _initialize_agent(self):
+        prompt = ChatPromptTemplate.from_messages([
+            SystemMessage(content="You are a helpful assistant with access to tools. Always use tools when appropriate."),
+            HumanMessagePromptTemplate.from_template("{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ])
+        self.agent = create_openai_functions_agent(self.llm, self.tools, prompt)
+        self.executor = FormatSafeAgentExecutor(
+            agent=self.agent,
+            tools=self.tools,
+            max_iterations=20,
+            verbose=self.verbose,
+            handle_parsing_errors=True,
+        )
+
+    # ------------------------------------------------------------------
+    # Long-term memory operations via adapter
+    # ------------------------------------------------------------------
+    def _update_long_term_memory(self, user_input: str, response: Any) -> None:
+        self.memory_manager.add_interaction(user_input=user_input, assistant_output=str(response), tags=["chat", "conversation"], tier="long")
+
+    def _retrieve_relevant_memories(self, query: str) -> List[str]:
+        # Fetch candidates, rerank inside adapter
+        results: List[SearchResult] = self.memory_manager.retrieve(
+            query=query,
+            top_k=self.rerank_candidates,
+            threshold=self.score_threshold,
+            tags=None,
+            rerank=True,
+        )
+        # Take top-k after rerank
+        results = results[:self.rerank_k]
+        return [r.text for r in results]
+
+
+    def clear_long_term_memory(self) -> None:
+        """Clear all long-term memories from HANA."""
+        try:
+            self.memory_manager.clear_all()
+            logger.info("Mem0 long-term memory cleared.")
+        except Exception as e:
+            logger.error("Failed to clear long-term memory: %s", e)
+
+
+    # ------------------------------------------------------------------
+    # Public chat API
+    # ------------------------------------------------------------------
+    def chat(self, user_input: str) -> str:
+        """Process user input and return agent response, managing long-term memory."""
+        if user_input.startswith("!clear_long_term_memory"):
+            self.clear_long_term_memory()
+            return "Long-term memory has been cleared."
+
+        if user_input.startswith("!delete_expired"):
+            deleted = self.memory_manager.delete_expired()
+            return f"Expired memories deleted: {deleted}."
+
+        if user_input.startswith("!export_memories"):
+            try:
+                rows = self.memory_manager.export()
+                return f"Exported memories: {len(rows)} rows."
+            except Exception as e:
+                return f"Export failed: {e}"
+
+        if user_input.strip() == "!auto_ingest_on":
+            self.memory_manager.set_auto_classification_enabled(True)
+            return "Auto ingestion classification enabled."
+
+        if user_input.strip() == "!auto_ingest_off":
+            self.memory_manager.set_auto_classification_enabled(False)
+            return "Auto ingestion classification disabled."
+
+        if user_input.strip() == "!auto_entity_on":
+            self.memory_manager.set_auto_entity_extraction_enabled(True)
+            return "Auto entity extraction enabled."
+
+        if user_input.strip() == "!auto_entity_off":
+            self.memory_manager.set_auto_entity_extraction_enabled(False)
+            return "Auto entity extraction disabled."
+
+        if user_input.startswith("!entity_assignment "):
+            try:
+                _, mode = user_input.split(maxsplit=1)
+                self.memory_manager.set_entity_assignment_mode(mode)
+                return f"Entity assignment mode set to: {mode}."
+            except Exception:
+                return "Usage: !entity_assignment <manager|extract|merge>"
+
+        if user_input.startswith("!set_ttl_long "):
+            try:
+                _, sec = user_input.split(maxsplit=1)
+                self.memory_manager.set_default_ttl_seconds(int(sec))
+                return f"Default long-term TTL set to: {sec} seconds."
+            except Exception:
+                return "Usage: !set_ttl_long <seconds>"
+
+        if user_input.startswith("!set_ttl_short "):
+            try:
+                _, sec = user_input.split(maxsplit=1)
+                self.memory_manager.set_short_term_ttl_seconds(int(sec))
+                return f"Default short-term TTL set to: {sec} seconds."
+            except Exception:
+                return "Usage: !set_ttl_short <seconds>"
+
+        if user_input.startswith("!search_short "):
+            try:
+                _, q = user_input.split(maxsplit=1)
+                results = self.memory_manager.retrieve_by_tier(query=q, tier="short", top_k=self.rerank_k, threshold=self.score_threshold, rerank=True)
+                texts = [r.text for r in results]
+                return f"Short-term hits ({len(texts)}):\n" + "\n".join(texts)
+            except Exception as e:
+                return f"search_short failed: {e}"
+
+        if user_input.startswith("!search_long "):
+            try:
+                _, q = user_input.split(maxsplit=1)
+                results = self.memory_manager.retrieve_by_tier(query=q, tier="long", top_k=self.rerank_k, threshold=self.score_threshold, rerank=True)
+                texts = [r.text for r in results]
+                return f"Long-term hits ({len(texts)}):\n" + "\n".join(texts)
+            except Exception as e:
+                return f"search_long failed: {e}"
+
+        if user_input.startswith("!set_entity "):
+            try:
+                _, eid, etype = user_input.split(maxsplit=2)
+                self.memory_manager.set_entity(eid, etype)
+                return f"Entity set to id={eid}, type={etype}."
+            except Exception:
+                return "Usage: !set_entity <entity_id> <entity_type>"
+
+
+        # Build context string via adapter memories
+        long_term_context = self._retrieve_relevant_memories(user_input)
+        context_str = "\n".join(long_term_context) if long_term_context else ""
+        agent_input = {
+            "input": [{
+                "type": "text",
+                "text": f"Context:\n{context_str}\n\nQuestion: {user_input}",
+            }]
+        }
+        response = self.executor.invoke(agent_input)
+        output = response["output"]
+        self._update_long_term_memory(user_input, output)
+        return output