CONTEXT_PROVISION_ANALYSIS.md

Context Provision Analysis: Intent Agent Context Flow

Problem Statement

The Intent Recognition Agent (src/agents/intent_agent.py) expects a context dictionary with a conversation_history key, but the actual context structure provided by EfficientContextManager does not include this key. This results in Available Context: [] being shown in the intent recognition prompt.

Context Flow Trace

Step 1: Orchestrator Retrieves Context

Location: src/orchestrator_engine.py:172

context = await self._get_or_create_context(session_id, user_input, user_id)

This calls context_manager.manage_context() which returns a context dictionary.

Step 2: Context Structure Returned by Context Manager

Location: src/context_manager.py:550-579 (_optimize_context method)

The context manager returns the following structure:

{
    "session_id": str,
    "user_id": str,
    "user_context": str,  # 500-token user persona summary
    "interaction_contexts": [  # List of interaction summary dicts
        {
            "summary": str,  # 50-token interaction summary
            "timestamp": str
        },
        ...
    ],
    "combined_context": str,  # Formatted string: "[User Context]\n...\n[Interaction Context #N]\n..."
    "preferences": dict,
    "active_tasks": list,
    "last_activity": str
}

Step 3: Intent Agent Receives Context

Location: src/orchestrator_engine.py:201-203

intent_result = await self.agents['intent_recognition'].execute(
    user_input=user_input,
    context=context
)

Step 4: Intent Agent Attempts to Access Context

Location: src/agents/intent_agent.py:109

def _build_chain_of_thought_prompt(self, user_input: str, context: Dict[str, Any]) -> str:
    return f"""
    Analyze the user's intent step by step:

    User Input: "{user_input}"
    
    Available Context: {context.get('conversation_history', [])[-2:] if context else []}
    ...
    """

Issue: The code attempts to access context.get('conversation_history', []), but the context dictionary does not contain this key.

Root Cause Analysis

Expected Context Structure (by Intent Agent)

The intent agent expects:

context = {
    'conversation_history': [
        {...},  # Previous conversation turn
        {...},  # Another previous turn
        ...
    ]
}

Actual Context Structure (from Context Manager)

The context manager provides:

context = {
    'interaction_contexts': [
        {'summary': '...', 'timestamp': '...'},
        {'summary': '...', 'timestamp': '...'},
        ...
    ],
    'user_context': '...',
    'combined_context': '...',
    ...
}

Why This Mismatch Exists

1. Historical Evolution: The intent agent was likely designed with an earlier context structure in mind
2. Context Manager Redesign: The context manager was redesigned to use hierarchical summarization (50/100/500 token tiers) instead of full conversation history
3. Missing Adaptation: The intent agent was not updated to use the new context structure

Impact Analysis

First Turn (No Previous Context)

• interaction_contexts = [] (empty list)
• user_context = "" (empty string if first-time user)
• Result: Available Context: [] ✓ (Correct, but for wrong reason - key doesn't exist)

Second Turn (After First Interaction)

• interaction_contexts = [{summary: "...", timestamp: "..."}] (1 interaction)
• user_context = "" or persona summary if user has history
• Result: Available Context: [] ✗ (Incorrect - context exists but wrong key accessed)

Third Turn and Beyond

• interaction_contexts = [{...}, {...}, ...] (multiple interactions)
• user_context = Persona summary (if user has sufficient history)
• Result: Available Context: [] ✗ (Incorrect - rich context exists but not accessible)

Context Accumulation Over Multiple Turns

Turn 1: User says "What is machine learning?"

1. Context Manager retrieves context:

   • interaction_contexts: [] (no previous interactions)
   • user_context: "" (first-time user, no persona yet)
   • Context passed to intent agent

2. Intent Agent builds prompt:

   • context.get('conversation_history', [])[-2:] → []
   • Shows: Available Context: []

3. After response, interaction context generated:

   • generate_interaction_context() called
   • Creates 50-token summary: "User asked about machine learning definition"
   • Stored in interaction_contexts table

Turn 2: User says "How does it differ from deep learning?"

1. Context Manager retrieves context:

   • interaction_contexts: [{summary: "User asked about machine learning definition", timestamp: "..."}]
   • user_context: Still "" (not enough history for persona)
   • Context passed to intent agent

2. Intent Agent builds prompt:

   • context.get('conversation_history', [])[-2:] → [] (key doesn't exist!)
   • Shows: Available Context: [] ✗ SHOULD show the interaction summary

3. After response, another interaction context generated:

   • Creates: "User asked about differences between machine learning and deep learning"
   • Stored in interaction_contexts table
   • Now has 2 interaction contexts

Turn 3: User says "Can you explain neural networks?"

1. Context Manager retrieves context:

   • interaction_contexts: [{summary: "...deep learning..."}, {summary: "...machine learning..."}]
   • user_context: Still "" (persona generated only after sufficient history)
   • Context passed to intent agent

2. Intent Agent builds prompt:

   • context.get('conversation_history', [])[-2:] → [] (key doesn't exist!)
   • Shows: Available Context: [] ✗ SHOULD show 2 interaction summaries

After ~20-50 Interactions (User Persona Generation)

1. Context Manager retrieves context:

   • interaction_contexts: [{...}, {...}, ...] (up to 20 most recent)
   • user_context: "User persona: Interested in AI topics, asks technical questions..." (500-token summary)
   • Context passed to intent agent

2. Intent Agent builds prompt:

   • context.get('conversation_history', [])[-2:] → [] (key doesn't exist!)
   • Shows: Available Context: [] ✗ SHOULD show rich context including user persona and interaction history

Available Context Data (Not Being Used)

What Context Actually Contains

Turn 1:

context = {
    "interaction_contexts": [],  # Empty - first turn
    "user_context": "",  # Empty - first-time user
    "combined_context": "",  # Empty
}

Turn 2:

context = {
    "interaction_contexts": [
        {"summary": "User asked about machine learning definition", "timestamp": "..."}
    ],
    "user_context": "",  # Still empty
    "combined_context": "[Interaction Context #1]\nUser asked about machine learning definition",
}

Turn 3+:

context = {
    "interaction_contexts": [
        {"summary": "User asked about differences between ML and DL", "timestamp": "..."},
        {"summary": "User asked about machine learning definition", "timestamp": "..."},
        # ... more interactions
    ],
    "user_context": "User persona: Interested in AI topics...",  # If sufficient history
    "combined_context": "[User Context]\nUser persona...\n\n[Interaction Context #2]\n...\n\n[Interaction Context #1]\n...",
}

Recommended Solutions

Option 1: Use interaction_contexts Directly (Minimal Change)

Modify: src/agents/intent_agent.py:109

# OLD:
Available Context: {context.get('conversation_history', [])[-2:] if context else []}

# NEW:
Available Context: {[ic.get('summary', '') for ic in context.get('interaction_contexts', [])[-2:]] if context else []}

Pros:

• Minimal code change
• Uses actual context data
• Shows last 2 interaction summaries

Cons:

• Only shows summaries, not full conversation
• Loses timestamp information

Option 2: Use combined_context (Preferred)

Modify: src/agents/intent_agent.py:109

# OLD:
Available Context: {context.get('conversation_history', [])[-2:] if context else []}

# NEW:
Available Context: {context.get('combined_context', 'No previous context available') if context else 'No context available'}

Pros:

• Uses pre-formatted context string
• Includes both user context and interaction contexts
• More informative for intent recognition
• Better reflects the hierarchical context system

Cons:

• May include more than just last 2 turns (includes up to 10 interactions)
• Longer context string

Option 3: Build Conversation History from Interaction Contexts (Most Flexible)

Modify: src/agents/intent_agent.py:101-118

def _build_chain_of_thought_prompt(self, user_input: str, context: Dict[str, Any]) -> str:
    """Build Chain of Thought prompt for intent recognition"""
    
    # Extract conversation history from interaction_contexts
    conversation_history = []
    if context:
        interaction_contexts = context.get('interaction_contexts', [])
        # Get last 2 interaction summaries for context
        for ic in interaction_contexts[-2:]:
            conversation_history.append({
                'summary': ic.get('summary', ''),
                'timestamp': ic.get('timestamp', '')
            })
    
    # Optionally include user context
    user_context_summary = ""
    if context and context.get('user_context'):
        user_context_summary = f"\nUser Context: {context.get('user_context')[:200]}..."  # Truncate for brevity
    
    return f"""
    Analyze the user's intent step by step:

    User Input: "{user_input}"
    
    Previous Context: {conversation_history if conversation_history else 'No previous interactions'}
    {user_context_summary}
    
    Step 1: Identify key entities, actions, and questions in the input
    Step 2: Map to intent categories: {', '.join(self.intent_categories)}
    Step 3: Consider the conversation flow and user's likely goals
    Step 4: Assign confidence scores (0.0-1.0) for each relevant intent
    Step 5: Provide reasoning for the classification
    
    Respond with JSON format containing primary_intent, secondary_intents, confidence_scores, and reasoning_chain.
    """

Pros:

• Flexible format
• Can include both interaction history and user context
• Properly handles empty context
• More informative for LLM

Cons:

• More code changes
• Slightly more complex

Current Behavior Summary

Turn	Interaction Contexts Available	User Context Available	Intent Agent Sees
1	0	No	[] (empty)
2	1	No	[] (empty) ✗
3	2	Possibly	[] (empty) ✗
10+	10-20	Yes (if sufficient history)	[] (empty) ✗

Key Issue: Intent agent never sees the available context data because it looks for the wrong key (conversation_history instead of interaction_contexts or combined_context).

Testing Recommendations

1. Verify Context Structure: Log the actual context dict passed to intent agent
2. Test Multiple Turns: Verify context accumulates correctly over multiple interactions
3. Test Persona Generation: Verify user_context appears after sufficient history
4. Compare Intent Accuracy: Measure if fixing context access improves intent recognition accuracy

Implementation Priority

High Priority: This bug prevents the intent agent from using available conversation context, which likely:

• Reduces intent recognition accuracy for follow-up questions
• Prevents context-aware intent classification
• Wastes the hierarchical context summarization system

Recommended Fix: Option 2 (Use combined_context) as it's the simplest and most comprehensive solution.