Managing and Reducing Costs › Strategy 5: Trim Conversation History

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

class HistoryOptimizedAgent:
    """Agent that manages conversation history efficiently."""
    
    def __init__(self):
        self.conversation_history = []
        self.max_history_messages = 6  # Keep last 3 exchanges
    
    def _trim_history(self):
        """Keep only recent messages to reduce token costs."""
        if len(self.conversation_history) > self.max_history_messages:
            # Keep only the most recent messages
            self.conversation_history = self.conversation_history[-self.max_history_messages:]
    
    def _estimate_tokens(self, text):
        """Rough token estimate (4 chars ≈ 1 token)."""
        return len(text) // 4
    
    def respond(self, user_message):
        """Generate response with optimized history."""
        # Add user message to history
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        # Trim history before sending
        self._trim_history()
        
        # Calculate token usage
        total_input_chars = sum(
            len(msg["content"]) for msg in self.conversation_history
        )
        estimated_input_tokens = total_input_chars // 4
        
        # Make the call
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=512,
            messages=self.conversation_history
        )
        
        # Add assistant response to history
        assistant_message = response.content[0].text
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        # Calculate cost
        input_cost = (response.usage.input_tokens / 1_000_000) * 3.00
        output_cost = (response.usage.output_tokens / 1_000_000) * 15.00
        total_cost = input_cost + output_cost
        
        return {
            "response": assistant_message,
            "input_tokens": response.usage.input_tokens,
            "output_tokens": response.usage.output_tokens,
            "cost": total_cost,
            "history_length": len(self.conversation_history)
        }

## Test with a multi-turn conversation
agent = HistoryOptimizedAgent()

queries = [
    "What is Python?",
    "What are its main features?",
    "How does it compare to Java?",
    "What about performance?",
    "Should I learn it?",
    "What resources do you recommend?",
    "How long will it take?",
    "What projects should I build?"
]

total_cost = 0.0

for query in queries:
    result = agent.respond(query)
    total_cost += result["cost"]
    
    print(f"Q: {query}")
    print(f"Input tokens: {result['input_tokens']}")
    print(f"History length: {result['history_length']} messages")
    print(f"Cost: ${result['cost']:.6f}")
    print()

print(f"Total conversation cost: ${total_cost:.4f}")
print("\nNote: Without trimming, costs would be ~40% higher")