Intelligent Conversation Compaction

Structured summarization that preserves topic, goals, decisions, and action items across long conversations

Intelligent Conversation Compaction extracts the conversation’s topic, current goal, key decisions, and action items into a structured summary that preserves narrative continuity.

from praisonaiagents import Agent, ManagerConfig

agent = Agent(
    name="LongChat",
    instructions="Help across many turns without losing thread",
    context=ManagerConfig(auto_compact=True, strategy="conversation", conversation_compaction=True),
)
agent.start("Continue our planning session from yesterday")

The user keeps chatting; long history compacts into structured topic, goals, and action items before the next reply.

Quick Start

1. Enable on Agent via ManagerConfig

   from praisonaiagents import Agent, ManagerConfig
   
   agent = Agent(
       name="LongChat",
       instructions="Help the user across many turns.",
       context=ManagerConfig(
           auto_compact=True,
           strategy="conversation",
           conversation_compaction=True,
           conversation_analyzer_strategy="hybrid",
           conversation_min_compaction_ratio=0.3,
       ),
   )
   
   agent.start("Let's design a new product over the next few hours...")

2. Low-Level Class

   from praisonaiagents import ConversationOptimizer
   
   optimizer = ConversationOptimizer(
       analyzer_strategy="hybrid",
       preserve_recent=5,
       min_compaction_ratio=0.3,
   )
   compacted_messages, stats = optimizer.optimize(messages, target_tokens=4000)

3. Direct API for full control

   from praisonaiagents import (
       get_conversation_analyzer,
       get_conversation_compactor,
   )
   
   analyzer = get_conversation_analyzer(strategy="hybrid")
   compactor = get_conversation_compactor(analyzer, min_compaction_ratio=0.3)
   
   compacted, context = compactor.compact_conversation(
       messages,
       target_tokens=4000,
       preserve_recent=5,
   )
   print(context.main_topic, context.current_goal, context.key_decisions)

How It Works

Analyzer Strategy Decision:

ConversationContext Shape

.to_summary_message() example output:

[💬 **Conversation Summary** - 47 messages compacted]

📋 **Topic**: Product design for developer tools
🎯 **Current Goal**: Create wireframes for the main dashboard
📈 **Progress**: Defined user personas, sketched initial layouts
🔑 **Key Decisions**:
• Using React with TypeScript
• Focus on mobile-first design
• Integrate with GitHub API
💡 **Important Context**:
• Users prefer dark mode interface
• Performance is critical for large repos
✅ **Action Items**:
• Finalize color scheme
• Create interactive prototype
⚙️ **User Preferences**: minimal UI, keyboard shortcuts, offline support

ManagerConfig Fields

OptimizerStrategy.CONVERSATION

Use strategy="conversation" for:

• Long conversations with topic evolution — preserves narrative flow better than basic summarization
• Multi-hour planning sessions — tracks decisions and action items across topic changes
• Iterative development — maintains context of completed work and next steps

When to use different strategies:

• strategy="conversation" → Structured summaries with topic/goal tracking
• strategy="smart" → Adaptive optimization (pruning, sliding window, etc.)
• strategy="summarize" → Simple LLM summarization without structure

Common Patterns

Multi-hour planning sessions:

agent = Agent(
    name="ProductPlanner",
    instructions="Help design products over extended sessions.",
    context=ManagerConfig(
        auto_compact=True,
        strategy="conversation",
        conversation_compaction=True,
        conversation_min_compaction_ratio=0.3,
    ),
)

Agent handoff with context preservation:

# First agent analyzes conversation
analyzer = get_conversation_analyzer(strategy="hybrid")
context = analyzer.analyze_conversation(messages)

# Pass structured context to new agent
new_agent.start(f"""
Continue this conversation about {context.main_topic}.
Current goal: {context.current_goal}
Progress: {context.progress_summary}
Recent decisions: {'; '.join(context.key_decisions[-3:])}
""")

Recover from ineffective basic summarization:

# If basic summarization lost important context
compactor = get_conversation_compactor(
    analyzer=get_conversation_analyzer("hybrid"),
    min_compaction_ratio=0.3
)
recovered_messages, rich_context = compactor.compact_conversation(
    original_messages,
    target_tokens=4000,
    preserve_recent=5
)

Best Practices

= 0.3″> Setting the minimum compaction ratio to at least 30% ensures summaries provide meaningful token savings. Lower ratios may waste computational resources on minimal gains.

Related