Comprehensive comparison for Memory Systems technology in AI applications

from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
from typing import Dict, Optional
import logging
import os

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class CustomerSupportAgent:
    """Production-ready customer support agent with conversation memory."""
    
    def __init__(self, customer_id: str, use_summary: bool = False):
        """
        Initialize customer support agent with memory.
        
        Args:
            customer_id: Unique identifier for the customer
            use_summary: If True, use summary memory for long conversations
        """
        self.customer_id = customer_id
        
        try:
            api_key = os.getenv("OPENAI_API_KEY")
            if not api_key:
                raise ValueError("OPENAI_API_KEY environment variable not set")
            
            self.llm = ChatOpenAI(
                temperature=0.7,
                model_name="gpt-3.5-turbo",
                api_key=api_key
            )
            
            if use_summary:
                self.memory = ConversationSummaryMemory(
                    llm=self.llm,
                    memory_key="chat_history",
                    return_messages=True
                )
            else:
                self.memory = ConversationBufferMemory(
                    memory_key="chat_history",
                    return_messages=True,
                    output_key="response"
                )
            
            prompt_template = PromptTemplate(
                input_variables=["chat_history", "input"],
                template="""You are a helpful customer support agent. Use the conversation history to provide personalized assistance.
                
Conversation History:
{chat_history}

Customer: {input}
Agent:"""
            )
            
            self.conversation = ConversationChain(
                llm=self.llm,
                memory=self.memory,
                prompt=prompt_template,
                verbose=False
            )
            
            logger.info(f"Initialized support agent for customer {customer_id}")
            
        except Exception as e:
            logger.error(f"Failed to initialize support agent: {str(e)}")
            raise
    
    def handle_message(self, user_input: str) -> Dict[str, str]:
        """
        Process customer message and return response.
        
        Args:
            user_input: Customer's message
            
        Returns:
            Dictionary containing response and status
        """
        if not user_input or not user_input.strip():
            return {
                "status": "error",
                "response": "Please provide a valid message"
            }
        
        try:
            response = self.conversation.predict(input=user_input)
            
            logger.info(f"Customer {self.customer_id}: Successfully processed message")
            
            return {
                "status": "success",
                "response": response,
                "customer_id": self.customer_id
            }
            
        except Exception as e:
            logger.error(f"Error processing message for {self.customer_id}: {str(e)}")
            return {
                "status": "error",
                "response": "I apologize, but I'm experiencing technical difficulties. Please try again."
            }
    
    def get_conversation_history(self) -> str:
        """Retrieve the full conversation history."""
        try:
            return self.memory.load_memory_variables({}).get("chat_history", "No history")
        except Exception as e:
            logger.error(f"Error retrieving history: {str(e)}")
            return "Unable to retrieve history"
    
    def clear_history(self) -> bool:
        """Clear conversation memory."""
        try:
            self.memory.clear()
            logger.info(f"Cleared history for customer {self.customer_id}")
            return True
        except Exception as e:
            logger.error(f"Error clearing history: {str(e)}")
            return False


if __name__ == "__main__":
    agent = CustomerSupportAgent(customer_id="CUST_12345")
    
    result1 = agent.handle_message("Hi, I need help with my order #98765")
    print(f"Response 1: {result1['response']}")
    
    result2 = agent.handle_message("What's the status of that order?")
    print(f"Response 2: {result2['response']}")
    
    print(f"\nConversation History:\n{agent.get_conversation_history()}")