How do you design a persistent memory and personalized agentic AI system with decay and self-evaluation?

Random import, math and time
Type Import List


Class MemoryItem
 Def __init__ (self, sort:str content:str score:float=1.0 kind:str)
 Self-kind = Kind
 "self-content" = content
 Score = self.score
       self.t = time.time()


MemoryStore Class:
   def __init__(self, decay_half_life=1800):
 Self-items List[MemoryItem] = []
       self.decay_half_life = decay_half_life


   def _decay_factor(self, item:MemoryItem):
       dt = time.time() - item.t
       return 0.5 ** (dt / self.decay_half_life)

 Def add (self, type:str and content:str with score:float=1.0),
       self.items.append(MemoryItem(kind, content, score))


   def search(self, query:str, topk=3):
 Score = []
 For it in Self.items
           decay = self._decay_factor(it)
           sim = len(set(query.lower().split()) & set(it.content.lower().split()))
           final = (it.score * decay) + sim
           scored.append((final, it))
       scored.sort(key=lambda x: x[0], reverse=True)
 Return to the Homepage [it for _, it in scored[:topk] if _ > 0]


   def cleanup(self, min_score=0.1):
 NEW = []
 For it in Self.items
           if it.score * self._decay_factor(it) > min_score:
               new.append(it)
 Self.items is new

class Agent
   def __init__(self, memory:MemoryStore, name="PersonalAgent"):
 Memory = self-memory
 Self-name = Name


   def _llm_sim(self, prompt:str, context:List[str]):
 Base = "OK. "
 If any ("prefers short" "in c for C in context":
 Base = ""
 "Reply" = base plus f"I considered {len(context)} past notes. "
 If "summarize" Lowercase():
 Retourner + "Summary: " + " | ".join(context[:2])
 If "recommend" Lowercase():
 If you have any questions, please feel free to ask."cybersecurity" "in c for C in context":
 Return reply "Recommended: write more cybersecurity articles."
 If you have any questions, please feel free to ask."rag" "in c for C in context":
 Return reply "Recommended: build an agentic RAG demo next."
 Retourner + "Recommended: continue with your last topic."
 Return reply "Here's my response to: " + prompt


   def perceive(self, user_input:str):
       ui = user_input.lower()
 If "i like" in ui or "i prefer" in ui:
           self.memory.add("preference", user_input, 1.5)
 If "topic:" in ui:
           self.memory.add("topic", user_input, 1.2)
 If "project" in ui:
           self.memory.add("project", user_input, 1.0)
 Def act(self:user_input, str)
       mems = self.memory.search(user_input, topk=4)
 ctx= [m.content for m in mems]
       answer = self._llm_sim(user_input, ctx)
       self.memory.add("dialog"F"user said: {user_input}", 0.6)
       self.memory.cleanup()
 Return Answer, Ctx

def evaluate_personalisation(agent:Agent):
   agent.memory.add("preference", "User likes cybersecurity articles", 1.6)
   q = "Recommend what to write next"
   ans_personal, _ = agent.act(q)
   empty_mem = MemoryStore()
   cold_agent = Agent(empty_mem)
   ans_cold, _ = cold_agent.act(q)
 Gain = Len(ans_personal - cold)
 Return ans_personal ans_cold gain

mem = MemoryStore(decay_half_life=60)
Agent = Agent(mem).


print("=== Demo: teaching the agent about yourself ===")
Inputs = [
   "I prefer short answers.",
   "I like writing about RAG and agentic AI.",
   "Topic: cybersecurity, phishing, APTs.",
   "My current project is to build an agentic RAG Q&A system."
]
For inp:
   agent.perceive(inp)


print("n=== Now ask the agent something ===")
user_q = "Recommend what to write next in my blog"
Agent.act (user_q), ctx, = ans
print("USER:", user_q)
print("AGENT:", ans)
print("USED MEMORY:", ctx)


print("n=== Evaluate personalisation benefit ===")
p, c, g = evaluate_personalisation(agent)
print("With memory :", p)
print("Cold start  :", c)
print("Personalisation gain (chars):", g)


print("n=== Current memory snapshot ===")
For it in Agent.memory.items
   print(f"- {it.kind} | {it.content[:60]}... | score~{round(it.score,2)}")