Disclaimer best practicies Oracle for Security

templates/agent_template_backend_day_zero/.env

@@ -175,3 +175,17 @@ MCP_GATEWAY_TIMEOUT_SECONDS=60
 # MCP_GATEWAY_TOKEN=
 MCP_GATEWAY_AGENT_ID=telecom_contas
 MCP_GATEWAY_TENANT_ID=default
+
+###############################################################################
+# LONG-TERM MEMORY
+###############################################################################
+ENABLE_LONG_TERM_MEMORY=true
+LONG_TERM_MEMORY_PROVIDER=sqlite
+LONG_TERM_MEMORY_SQLITE_PATH=./data/agent_framework.db
+LONG_TERM_MEMORY_TABLE=agentfw_long_term_memory
+# For Autonomous/Oracle, defaults to ${ADB_TABLE_PREFIX}_LONG_TERM_MEMORY
+# LONG_TERM_MEMORY_ORACLE_TABLE=AGENTFW_LONG_TERM_MEMORY
+LONG_TERM_MEMORY_MAX_CONTEXT_ITEMS=20
+LONG_TERM_MEMORY_MIN_CONFIDENCE=0.70
+LONG_TERM_MEMORY_AUTO_EXTRACT=true
+LONG_TERM_MEMORY_INJECT_CONTEXT=true

templates/agent_template_backend_day_zero/app/state.py

@@ -33,3 +33,6 @@ class AgentState(TypedDict, total=False):
     supervisor_handover_reason: str
     output_supervisor_results: list[dict[str, Any]]
     output_guardrails_already_applied: bool
+    long_term_memories: list[dict[str, Any]]
+    long_term_memory_context: str
+    long_term_memory_write_result: dict[str, Any]

templates/agent_template_backend_day_zero/app/workflows/agent_graph.py

@@ -21,6 +21,7 @@ from app.state import AgentState
 from agent_framework.rag.rag_service import RagService
 from agent_framework.rag.embedding_provider import create_embedding_provider
 from agent_framework.cache.cache import create_cache
+from agent_framework.memory.long_term_memory import create_long_term_memory_manager
 
 
 class LegacyOutputGuardrailRail:
@@ -94,6 +95,7 @@ class AgentWorkflow:
         self.settings = settings
         self.tool_router = tool_router
         self.summary_memory = summary_memory
+        self.long_term_memory_manager = create_long_term_memory_manager(settings, telemetry=telemetry)
         self.guardrails = GuardrailPipeline(
             observer=self.observer,
             enable_parallel=bool(getattr(settings, "ENABLE_PARALLEL_GUARDRAILS", True)),
@@ -121,6 +123,11 @@ class AgentWorkflow:
         self.product = ProductAgent(llm, **agent_kwargs)
         self.orders = OrdersAgent(llm, **agent_kwargs)
         self.support = SupportAgent(llm, **agent_kwargs)
+
+        # The existing agent constructors intentionally keep their stable API.
+        # Long-term memory is injected as a runtime capability after creation.
+        for agent in (self.billing, self.product, self.orders, self.support):
+            agent.long_term_memory_manager = self.long_term_memory_manager
         self.graph = self._build_graph()
 
     def _node(self, name, fn):
@@ -143,6 +150,7 @@ class AgentWorkflow:
         builder.add_node("output_guardrails", self._node("output_guardrails", self.output_guardrails))
         builder.add_node("judge", self._node("judge", self.judge))
         builder.add_node("supervisor_review", self._node("supervisor_review", self.supervisor_review))
+        builder.add_node("persist_long_term_memory", self._node("persist_long_term_memory", self.persist_long_term_memory))
         builder.add_node("persist", self._node("persist", self.persist))
 
         builder.add_edge(START, "input_guardrails")
@@ -172,7 +180,8 @@ class AgentWorkflow:
         builder.add_edge("output_supervisor", "output_guardrails")
         builder.add_edge("output_guardrails", "judge")
         builder.add_edge("judge", "supervisor_review")
-        builder.add_edge("supervisor_review", "persist")
+        builder.add_edge("supervisor_review", "persist_long_term_memory")
+        builder.add_edge("persist_long_term_memory", "persist")
         builder.add_edge("persist", END)
 
         return builder.compile(checkpointer=create_langgraph_checkpointer(self.settings))
@@ -598,6 +607,10 @@ class AgentWorkflow:
             )
             return {"final_answer": answer if ok else answer}
 
+    async def persist_long_term_memory(self, state):
+        result = await self.long_term_memory_manager.persist_turn(state)
+        return {"long_term_memory_write_result": result}
+
     async def persist(self, state):
         async with self.telemetry.span(
             "workflow.persist",

templates/agent_template_backend_day_zero/scripts/test_long_term_memory.py

@@ -0,0 +1,29 @@
+import asyncio
+import tempfile
+from types import SimpleNamespace
+from agent_framework.memory.long_term_memory import create_long_term_memory_manager
+
+async def main():
+    with tempfile.TemporaryDirectory() as d:
+        settings = SimpleNamespace(
+            ENABLE_LONG_TERM_MEMORY=True,
+            LONG_TERM_MEMORY_PROVIDER='sqlite',
+            LONG_TERM_MEMORY_SQLITE_PATH=f'{d}/memory.db',
+            LONG_TERM_MEMORY_TABLE='agentfw_long_term_memory',
+            LONG_TERM_MEMORY_MAX_CONTEXT_ITEMS=20,
+            LONG_TERM_MEMORY_MIN_CONFIDENCE=0.70,
+            LONG_TERM_MEMORY_AUTO_EXTRACT=True,
+        )
+        manager = create_long_term_memory_manager(settings)
+        first = {'tenant_id':'default','agent_id':'memory_test','session_id':'a','user_text':'Me chame de Cris. Minha linguagem preferida é Python. Meu projeto atual se chama Atlas.','context':{'business_context':{'customer_key':'MEM-001'}}}
+        assert (await manager.persist_turn(first))['saved'] >= 3
+        second = {'tenant_id':'default','agent_id':'memory_test','session_id':'b','context':{'business_context':{'customer_key':'MEM-001'}}}
+        values = {item.key:item.value for item in await manager.load(second)}
+        assert values['preferred_name'].lower() == 'cris'
+        assert values['preferred_language'].lower() == 'python'
+        assert values['current_project'].lower() == 'atlas'
+        isolated = {'tenant_id':'default','agent_id':'memory_test','session_id':'c','context':{'business_context':{'customer_key':'MEM-002'}}}
+        assert await manager.load(isolated) == []
+        print('OK: persistência, recuperação entre sessões e isolamento validados')
+
+asyncio.run(main())