from abc import ABC, abstractmethod
from typing import Any, List, Dict

# Base interfaces for modular design
class PerceptionModule(ABC):
    @abstractmethod
    def process_input(self, input_data: Any) -> Dict[str, Any]:
        """Process raw input into structured format"""
        pass

class ReasoningModule(ABC):
    @abstractmethod
    def generate_plan(self, context: Dict[str, Any]) -> List[str]:
        """Generate action plan based on context"""
        pass

class MemoryModule(ABC):
    @abstractmethod
    def store(self, key: str, value: Any):
        """Store information in memory"""
        pass
    
    @abstractmethod
    def retrieve(self, key: str) -> Any:
        """Retrieve information from memory"""
        pass

# Main agent class using composition
class ModularAgent:
    def __init__(
        self,
        perception: PerceptionModule,
        reasoning: ReasoningModule,
        memory: MemoryModule
    ):
        self.perception = perception
        self.reasoning = reasoning
        self.memory = memory
    
    def execute(self, input_data: Any) -> Any:
        # 1. Perceive input
        context = self.perception.process_input(input_data)
        
        # 2. Retrieve relevant memories
        relevant_memories = self.memory.retrieve(context["topic"])
        context["memories"] = relevant_memories
        
        # 3. Reason and plan
        plan = self.reasoning.generate_plan(context)
        
        # 4. Store new memories
        self.memory.store(context["topic"], context)
        
        return plan

import chromadb
from typing import List, Dict, Any
from datetime import datetime

class HybridMemorySystem:
    def __init__(self):
        # Short-term memory (in-memory)
        self.short_term = []
        self.short_term_limit = 10
        
        # Long-term memory (vector database)
        self.chroma_client = chromadb.Client()
        self.long_term = self.chroma_client.create_collection(
            name="agent_memory"
        )
    
    def store_short_term(self, observation: str):
        """Store observation in short-term memory"""
        timestamp = datetime.now().isoformat()
        memory_entry = {
            "content": observation,
            "timestamp": timestamp,
            "type": "short_term"
        }
        
        self.short_term.append(memory_entry)
        
        # Maintain size limit
        if len(self.short_term) > self.short_term_limit:
            self._move_to_long_term(self.short_term.pop(0))
    
    def store_long_term(self, content: str, metadata: Dict[str, Any]):
        """Store information in long-term vector memory"""
        self.long_term.add(
            documents=[content],
            metadatas=[metadata],
            ids=[f"memory_{len(self.long_term.get()['ids'])}"]
        )
    
    def retrieve_relevant(self, query: str, n_results: int = 5) -> List[Dict]:
        """Retrieve relevant memories for a query"""
        # Get from short-term memory (most recent)
        short_term_results = self.short_term[-n_results:] if self.short_term else []
        
        # Get from long-term memory (semantic search)
        long_term_results = self.long_term.query(
            query_texts=[query],
            n_results=n_results
        )
        
        return short_term_results + long_term_results['documents']