InteractiveShort-Term Conversation Memory: Building Context-Aware AI Agents

import os
from anthropic import Anthropic

## Using Claude Sonnet 4.5 for its excellent conversational capabilities
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def ask_without_memory(question: str) -> str:
    """Ask a question without any conversation history."""
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": question}
        ]
    )
    return response.content[0].text

## First question
print("Q1:", ask_without_memory("What's the capital of France?"))
## Output: "The capital of France is Paris."

## Follow-up question
print("Q2:", ask_without_memory("What's the population?"))
## Output: "I'd be happy to help with population information, 
## but I need to know which location you're asking about."

def ask_with_memory(conversation_history: list, question: str) -> tuple:
    """
    Ask a question with full conversation context.
    
    Args:
        conversation_history: List of previous messages
        question: The new question to ask
    
    Returns:
        Tuple of (answer, updated_history)
    """
    # Add the new question to history
    conversation_history.append({
        "role": "user",
        "content": question
    })
    
    # Send entire conversation to the model
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        messages=conversation_history
    )
    
    # Extract the answer
    answer = response.content[0].text
    
    # Add the answer to history
    conversation_history.append({
        "role": "assistant",
        "content": answer
    })
    
    return answer, conversation_history

## Start with empty history
history = []

## First question
answer1, history = ask_with_memory(history, "What's the capital of France?")
print("Q1:", answer1)
## Output: "The capital of France is Paris."

## Follow-up question - now with context!
answer2, history = ask_with_memory(history, "What's the population?")
print("Q2:", answer2)
## Output: "Paris has a population of approximately 2.1 million people 
## within the city proper, and about 12 million in the greater 
## metropolitan area."

[
    {"role": "user", "content": "What's the capital of France?"},
    {"role": "assistant", "content": "The capital of France is Paris."},
    {"role": "user", "content": "What's the population?"},
    {"role": "assistant", "content": "Paris has a population of approximately..."}
]

class ConversationalAgent:
    """
    A personal assistant that remembers the conversation.
    """
    
    def __init__(self):
        self.client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
        self.conversation_history = []
        
    def chat(self, user_message: str) -> str:
        """
        Send a message and get a response, maintaining conversation history.
        
        Args:
            user_message: What the user wants to say
        
        Returns:
            The agent's response
        """
        # Add user message to history
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        # Get response with full context
        response = self.client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            messages=self.conversation_history
        )
        
        # Extract and store the response
        assistant_message = response.content[0].text
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        return assistant_message
    
    def clear_history(self):
        """Start a fresh conversation."""
        self.conversation_history = []
    
    def get_history(self) -> list:
        """Get the current conversation history."""
        return self.conversation_history.copy()

## Create the agent
agent = ConversationalAgent()

## Have a conversation
print(agent.chat("I'm planning a trip to Japan."))
## "That sounds exciting! Japan is a wonderful destination..."

print(agent.chat("What's the best time of year to visit?"))
## "For Japan, the best times to visit are typically spring (March-May) 
## for cherry blossoms, or autumn (September-November) for fall foliage..."

print(agent.chat("How long should I plan to stay?"))
## "For a first trip to Japan, I'd recommend at least 10-14 days..."

print(agent.chat("What cities should I include?"))
## "Based on your trip to Japan, I'd suggest including Tokyo, Kyoto, 
## and possibly Osaka or Hiroshima..."

agent = ConversationalAgent()

## Initial question
print(agent.chat("What are the main differences between Python and JavaScript?"))
## Detailed comparison of Python and JavaScript...

## Vague follow-up
print(agent.chat("Which one is easier to learn?"))
## "For beginners, Python is generally considered easier to learn..."

## Another vague follow-up
print(agent.chat("Why is that?"))
## "Python is easier to learn because of its clean, readable syntax..."

## Reference to earlier point
print(agent.chat("You mentioned async programming. Can you explain that more?"))
## "In JavaScript, async programming is central to how the language works..."

def calculate(expression: str) -> dict:
    """Simple calculator tool."""
    try:
        result = eval(expression)
        return {"success": True, "result": result}
    except Exception as e:
        return {"success": False, "error": str(e)}

calculator_tool = {
    "name": "calculate",
    "description": "Perform mathematical calculations",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Math expression to evaluate"
            }
        },
        "required": ["expression"]
    }
}

class ConversationalAgentWithTools:
    """Agent with memory and tool use."""
    
    def __init__(self):
        self.client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
        self.conversation_history = []
        self.tools = {"calculate": calculate}
    
    def chat(self, user_message: str) -> str:
        """Chat with tool use support."""
        # Add user message
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        # Get response
        response = self.client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            tools=[calculator_tool],
            messages=self.conversation_history
        )
        
        # Handle tool use if needed
        if response.stop_reason == "tool_use":
            # Extract tool call
            tool_use_block = next(
                block for block in response.content 
                if block.type == "tool_use"
            )
            
            # Call the tool
            tool_result = self.tools[tool_use_block.name](
                **tool_use_block.input
            )
            
            # Add tool use to history
            self.conversation_history.append({
                "role": "assistant",
                "content": response.content
            })
            
            # Add tool result to history
            self.conversation_history.append({
                "role": "user",
                "content": [{
                    "type": "tool_result",
                    "tool_use_id": tool_use_block.id,
                    "content": str(tool_result)
                }]
            })
            
            # Get final response
            final_response = self.client.messages.create(
                model="claude-sonnet-4-5",
                max_tokens=1024,
                tools=[calculator_tool],
                messages=self.conversation_history
            )
            
            assistant_message = final_response.content[0].text
        else:
            assistant_message = response.content[0].text
        
        # Add final response to history
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        return assistant_message

agent = ConversationalAgentWithTools()

print(agent.chat("What's 1234 times 5678?"))
## Agent uses calculator tool
## "1,234 times 5,678 equals 7,006,652."

print(agent.chat("What if I double that?"))
## Agent remembers the previous result
## Agent calculates 7006652 * 2
## "Doubling that gives you 14,013,304."

print(agent.chat("And what's 10% of the original number?"))
## Agent remembers 7,006,652 was the original
## Agent calculates 7006652 * 0.1
## "10% of the original number (7,006,652) is 700,665.2."

## After a long conversation
print(f"Messages in history: {len(agent.conversation_history)}")
## Output: 156 messages

## Estimate token count (rough approximation)
total_chars = sum(len(str(msg)) for msg in agent.conversation_history)
estimated_tokens = total_chars // 4  # Rough estimate: 1 token ≈ 4 characters
print(f"Estimated tokens: {estimated_tokens}")
## Output: Estimated tokens: 12,450

class ConversationalAgentWithWindow:
    """Agent with sliding window memory."""
    
    def __init__(self, max_messages: int = 20):
        self.client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
        self.conversation_history = []
        self.max_messages = max_messages
    
    def chat(self, user_message: str) -> str:
        """Chat with sliding window memory."""
        # Add user message
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        # Keep only recent messages
        if len(self.conversation_history) > self.max_messages:
            # Keep the most recent max_messages
            self.conversation_history = self.conversation_history[-self.max_messages:]
        
        # Get response with limited history
        response = self.client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            messages=self.conversation_history
        )
        
        assistant_message = response.content[0].text
        
        # Add response to history
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        # Trim again if needed
        if len(self.conversation_history) > self.max_messages:
            self.conversation_history = self.conversation_history[-self.max_messages:]
        
        return assistant_message

class ConversationalAgentWithSummary:
    """Agent with conversation summarization."""
    
    def __init__(self, summarize_after: int = 20):
        self.client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
        self.conversation_history = []
        self.summarize_after = summarize_after
    
    def _summarize_history(self, messages: list) -> str:
        """Create a summary of conversation history."""
        # Format the conversation
        conversation_text = "\n".join([
            f"{msg['role'].title()}: {msg['content']}"
            for msg in messages
        ])
        
        # Ask the model to summarize
        response = self.client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=500,
            messages=[{
                "role": "user",
                "content": f"""Summarize this conversation, preserving key facts, 
                decisions, and context that might be referenced later:
                
                {conversation_text}
                
                Provide a concise summary in 2-3 paragraphs."""
            }]
        )
        
        return response.content[0].text
    
    def chat(self, user_message: str) -> str:
        """Chat with automatic summarization."""
        # Add user message
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        # Check if we should summarize
        if len(self.conversation_history) > self.summarize_after:
            # Take first half of messages to summarize
            to_summarize = self.conversation_history[:self.summarize_after // 2]
            keep_recent = self.conversation_history[self.summarize_after // 2:]
            
            # Create summary
            summary = self._summarize_history(to_summarize)
            
            # Replace old messages with summary
            self.conversation_history = [
                {
                    "role": "user",
                    "content": f"[Previous conversation summary: {summary}]"
                }
            ] + keep_recent
        
        # Get response
        response = self.client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            messages=self.conversation_history
        )
        
        assistant_message = response.content[0].text
        
        # Add response
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        return assistant_message

class SmartConversationalAgent:
    """Agent with intelligent memory management."""
    
    def __init__(self,
                 window_size: int = 30,
                 summarize_threshold: int = 50):
        self.client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
        self.conversation_history = []
        self.window_size = window_size
        self.summarize_threshold = summarize_threshold
        self.summary = None
    
    def chat(self, user_message: str) -> str:
        """Chat with smart memory management."""
        # Add message
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        # Manage memory
        if len(self.conversation_history) > self.summarize_threshold:
            # Summarize old messages
            old_messages = self.conversation_history[:-self.window_size]
            self.summary = self._summarize(old_messages)
            self.conversation_history = self.conversation_history[-self.window_size:]
        
        # Build context
        messages = []
        if self.summary:
            messages.append({
                "role": "user",
                "content": f"[Context from earlier: {self.summary}]"
            })
        messages.extend(self.conversation_history)
        
        # Get response
        response = self.client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            messages=messages
        )
        
        assistant_message = response.content[0].text
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        return assistant_message