File size: 2,177 Bytes
25732fb
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
"""
Base Agent Class - All agents inherit from this
"""
from abc import ABC, abstractmethod
import logging
from datetime import datetime

logging.basicConfig(level=logging.INFO)

class StudentState:
    """Standardized student state object for agent perception"""
    def __init__(self, user_id, **kwargs):
        self.user_id = user_id
        for key, value in kwargs.items():
            setattr(self, key, value)

class BaseAgent(ABC):
    """Base class for all autonomous agents"""
    
    def __init__(self, agent_id, name):
        self.agent_id = agent_id
        self.name = name
        self.state = "idle"
        self.memory = []
        self.logger = logging.getLogger(f"Agent-{name}")
        self.created_at = datetime.utcnow()
        
    def log(self, message, level="info"):
        """Log agent activities"""
        log_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "agent": self.name,
            "message": message,
            "state": self.state
        }
        self.memory.append(log_entry)
        
        if level == "info":
            self.logger.info(f"[{self.name}] {message}")
        elif level == "error":
            self.logger.error(f"[{self.name}] {message}")
        elif level == "warning":
            self.logger.warning(f"[{self.name}] {message}")
    
    def update_state(self, new_state):
        """Update agent state"""
        old_state = self.state
        self.state = new_state
        self.log(f"State transition: {old_state}{new_state}")
    
    @abstractmethod
    def perceive(self, environment):
        """Perceive the environment - to be implemented by subclasses"""
        pass
    
    @abstractmethod
    def decide(self):
        """Make autonomous decisions - to be implemented by subclasses"""
        pass
    
    @abstractmethod
    def act(self):
        """Execute actions - to be implemented by subclasses"""
        pass
    
    def get_memory(self, limit=10):
        """Retrieve recent memory"""
        return self.memory[-limit:]
    
    def clear_memory(self):
        """Clear agent memory"""
        self.memory = []
        self.log("Memory cleared")