MEMORY SYSTEMS:
AGENTS KO YAAD RAKHNA.

# Short-term memory - Current conversation
class ShortTermMemory:
 def __init__(self, max_size=10):
 self.max_size = max_size
 self.items = []
 
 def add(self, item):
 self.items.append(item)
 # Purane items hatao agar limit exceed ho
 if len(self.items) > self.max_size:
 self.items.pop(0) # Sabse purana hatao
 
 def get_recent(self, n=5):
 # Last n items return karo
 return self.items[-n:]
 
 def clear(self):
 self.items = []

# Usage
memory = ShortTermMemory(max_size=5)
memory.add("User: Python ka factorial function banao")
memory.add("Agent: def factorial(n): return 1 if n==0 else n*factorial(n-1)")
memory.add("User: Ab isko optimize karo")
memory.add("Agent: Iterative version banaya")
memory.add("User: Thank you!")

print(memory.get_recent(3))
# ['User: Ab isko optimize karo', 
# 'Agent: Iterative version banaya',
# 'User: Thank you!']

# Long-term memory - Persistent storage
import json
from datetime import datetime

class LongTermMemory:
 def __init__(self, filename="memory.json"):
 self.filename = filename
 self.items = []
 self.load()
 
 def add(self, item, category="general"):
 entry = {
 "content": item,
 "category": category,
 "timestamp": datetime.now().isoformat()
 }
 self.items.append(entry)
 self.save()
 
 def search(self, query):
 # Simple keyword search
 results = []
 for item in self.items:
 if query.lower() in item["content"].lower():
 results.append(item)
 return results
 
 def get_by_category(self, category):
 return [i for i in self.items if i["category"] == category]
 
 def save(self):
 with open(self.filename, 'w') as f:
 json.dump(self.items, f)
 
 def load(self):
 try:
 with open(self.filename, 'r') as f:
 self.items = json.load(f)
 except FileNotFoundError:
 self.items = []

# Usage
ltm = LongTermMemory()
ltm.add("User ka naam Rahul hai", category="user_info")
ltm.add("Rahul ko Python pasand hai", category="preferences")
ltm.add("Rahul ne Machine Learning course complete kiya", category="history")

print(ltm.search("Rahul"))
print(ltm.get_by_category("preferences"))

# Episodic memory - Past experiences
from datetime import datetime

class EpisodicMemory:
 def __init__(self):
 self.episodes = []
 
 def record_episode(self, topic, action, result, rating=None):
 episode = {
 "topic": topic,
 "action": action,
 "result": result,
 "rating": rating,
 "timestamp": datetime.now().isoformat()
 }
 self.episodes.append(episode)
 
 def get_similar_episodes(self, topic):
 # Similar topics dhundho
 return [e for e in self.episodes 
 if topic.lower() in e["topic"].lower()]
 
 def get_successful_episodes(self, topic):
 # Successful episodes filter karo
 similar = self.get_similar_episodes(topic)
 return [e for e in similar if e.get("rating", 0) >= 4]
 
 def learn_from_experience(self, topic):
 # Past se seekho
 episodes = self.get_successful_episodes(topic)
 if episodes:
 return f"Past mein {topic} ke liye: {episodes[-1]['action']} successful raha"
 return f"{topic} ke liye pehla attempt hai, best practices follow karo"

# Usage
ep_memory = EpisodicMemory()
ep_memory.record_episode("Python optimization", "loop optimization", "10x faster", 5)
ep_memory.record_episode("Web scraping", "BeautifulSoup use kiya", "success", 4)
ep_memory.record_episode("Python optimization", "list comprehension", "clean code", 5)

print(ep_memory.learn_from_experience("Python optimization"))
print(ep_memory.learn_from_experience("Web scraping"))

# Semantic memory - Knowledge & facts
class SemanticMemory:
 def __init__(self):
 self.facts = {} # General facts
 self.user_facts = {} # User-specific knowledge
 self.patterns = {} # Learned patterns
 
 def learn_fact(self, key, value, is_user_specific=False):
 if is_user_specific:
 self.user_facts[key] = value
 else:
 self.facts[key] = value
 
 def learn_pattern(self, pattern_name, rule):
 self.patterns[pattern_name] = rule
 
 def get_knowledge(self, key):
 # Pehle user-specific dekho, phir general
 if key in self.user_facts:
 return self.user_facts[key]
 return self.facts.get(key, "Knowledge not found")
 
 def apply_pattern(self, pattern_name, context):
 if pattern_name in self.patterns:
 return self.patterns[pattern_name](context)
 return "Pattern not found"

# Usage
sm = SemanticMemory()
sm.learn_fact("python_basics", "Variables, loops, functions")
sm.learn_fact("user_preference", "Rahul prefers concise code", is_user_specific=True)
sm.learn_pattern("greeting", lambda name: f"Hello, {name}!")

print(sm.get_knowledge("user_preference"))
print(sm.get_knowledge("python_basics"))
print(sm.apply_pattern("greeting", "Rahul"))

# Complete Memory System
class Memory:
 def __init__(self):
 self.short_term = [] # Current conversation
 self.long_term = [] # Persistent
 
 def add_short(self, item):
 self.short_term.append(item)
 if len(self.short_term) > 10:
 self.short_term.pop(0)
 
 def add_long(self, item):
 self.long_term.append(item)
 
 def recall_short(self, n=5):
 return self.short_term[-n:]
 
 def recall_long(self, query):
 return [item for item in self.long_term if query.lower() in str(item).lower()]
 
 def save(self, filename):
 import json
 with open(filename, 'w') as f:
 json.dump({"short": self.short_term, "long": self.long_term}, f)

# Usage
memory = Memory()
memory.add_short("User asked about Python")
memory.add_long({"topic": "Python basics", "learned": True})
print(memory.recall_short())
print(memory.recall_long("Python"))