Update app.py

app.py

@@ -146,6 +146,153 @@ from utils.api_client import RewardPilotClient
 from utils.llm_explainer import get_llm_explainer
 import config
 
+from agents.agent_core import RewardPilotAgent
+
+# Initialize agent
+agent = RewardPilotAgent()
+
+def get_recommendation_with_agent(user_id, merchant, category, amount):
+    """
+    Get recommendation using autonomous agent
+    Shows loading state, then agent's reasoning
+    """
+    import httpx
+    
+    # Show loading first
+    yield "⏳ **Agent is thinking...** Analyzing your transaction and cards...", None
+    
+    try:
+        transaction = {
+            "user_id": user_id,
+            "merchant": merchant,
+            "category": category,
+            "mcc": MCC_CATEGORIES.get(category, "5999"),
+            "amount_usd": float(amount)
+        }
+        
+        # Call orchestrator (which now uses agent)
+        response = httpx.post(
+            f"{config.ORCHESTRATOR_URL}/recommend",
+            json=transaction,
+            timeout=60.0  # Agent needs more time
+        )
+        
+        if response.status_code != 200:
+            yield f"❌ Error: API returned status {response.status_code}", None
+            return
+        
+        result = response.json()
+        
+        # Extract agent data safely
+        recommended_card = safe_get(result, 'recommended_card', {})
+        if isinstance(recommended_card, dict):
+            card_name = safe_get(recommended_card, 'card_name', 'Unknown Card')
+        else:
+            card_name = str(recommended_card)
+        
+        # Format response with agent insights
+        output = f"""
+## 🤖 AI Agent Recommendation
+
+### 💳 Recommended Card: **{card_name}**
+
+### 🧠 Agent's Reasoning:
+{safe_get(result, 'final_recommendation', 'No reasoning provided')}
+
+---
+
+### 📊 Quick Stats:
+- **Amount**: ${safe_get(result, 'amount_usd', amount):.2f}
+- **Merchant**: {safe_get(result, 'merchant', merchant)}
+- **Category**: {safe_get(result, 'category', category)}
+- **Services Used**: {', '.join(safe_get(result, 'services_used', []))}
+- **Processing Time**: {safe_get(result, 'orchestration_time_ms', 0):.0f}ms
+
+---
+
+### 💡 Why This Card?
+The AI agent analyzed your transaction context, card portfolio, and spending patterns to determine this is your optimal choice.
+
+**Confidence Level**: High ✅
+"""
+        
+        # Create simple comparison chart
+        chart = create_agent_recommendation_chart(result)
+        
+        yield output, chart
+        
+    except httpx.TimeoutException:
+        yield "⏱️ **Request timed out.** The agent is taking longer than expected. Please try again.", None
+    except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"Agent recommendation error: {error_details}")
+        yield f"❌ **Error**: {str(e)}\n\nPlease check the orchestrator service or try again.", None
+
+
+def create_agent_recommendation_chart(result: Dict) -> go.Figure:
+    """Create simple chart showing agent's recommendation"""
+    try:
+        # Extract card info
+        recommended = result.get('recommended_card', {})
+        alternatives = result.get('alternative_cards', [])[:2]  # Top 2 alternatives
+        
+        if isinstance(recommended, dict):
+            rec_name = recommended.get('card_name', 'Recommended Card')
+            rec_reward = recommended.get('reward_amount', 0)
+        else:
+            rec_name = str(recommended)
+            rec_reward = 0
+        
+        cards = [rec_name]
+        rewards = [rec_reward]
+        colors = ['#667eea']  # Purple for recommended
+        
+        # Add alternatives
+        for alt in alternatives:
+            if isinstance(alt, dict):
+                cards.append(alt.get('card_name', 'Alternative'))
+                rewards.append(alt.get('reward_amount', 0))
+                colors.append('#cbd5e0')  # Gray for alternatives
+        
+        # Create bar chart
+        fig = go.Figure(data=[
+            go.Bar(
+                x=cards,
+                y=rewards,
+                marker=dict(color=colors, line=dict(color='white', width=2)),
+                text=[f'${r:.2f}' for r in rewards],
+                textposition='outside',
+                hovertemplate='<b>%{x}</b><br>Rewards: $%{y:.2f}<extra></extra>'
+            )
+        ])
+        
+        fig.update_layout(
+            title={'text': '🎯 Agent\'s Card Comparison', 'x': 0.5, 'xanchor': 'center'},
+            xaxis_title='Credit Card',
+            yaxis_title='Rewards Earned ($)',
+            template='plotly_white',
+            height=400,
+            showlegend=False,
+            margin=dict(t=60, b=50, l=50, r=50)
+        )
+        
+        return fig
+        
+    except Exception as e:
+        print(f"Chart error: {e}")
+        fig = go.Figure()
+        fig.add_annotation(
+            text="Chart unavailable",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=14, color="#666")
+        )
+        fig.update_layout(height=400, template='plotly_white')
+        return fig
+
+
+        
 # Initialize clients
 client = RewardPilotClient(config.ORCHESTRATOR_URL)
 llm = get_llm_explainer()
@@ -561,9 +708,13 @@ Get AI-powered credit card recommendations that maximize your rewards based on:
 ---
 """
     )
-    # LLM Status Indicator
-    llm_status = "🤖 **AI Explanations:** ✅ Enabled" if config.LLM_ENABLED else "⚠️ **AI Explanations:** Disabled (using rule-based mode)"
-    gr.Markdown(llm_status)
+    # Agent Status Indicator
+    agent_status = """
+    🤖 **Autonomous Agent:** ✅ Active (Claude 3.5 Sonnet)  
+    📊 **Mode:** Dynamic Planning + Reasoning  
+    ⚡ **Services:** Smart Wallet + RAG + Forecast
+    """
+    gr.Markdown(agent_status)
     
     
     # Ensure all tabs are siblings at the same level
@@ -672,10 +823,10 @@ Get AI-powered credit card recommendations that maximize your rewards based on:
             
             
             recommend_btn.click(
-                fn=get_recommendation_with_ai,
-                inputs=[user_dropdown, merchant_dropdown, category_dropdown, amount_input],
-                outputs=[recommendation_output, recommendation_chart]
-            )
+                                    fn=get_recommendation_with_agent,  
+                                    inputs=[user_dropdown, merchant_dropdown, category_dropdown, amount_input],
+                                    outputs=[recommendation_output, recommendation_chart]
+                                )
             # def get_recommendation_with_loading(user_id, merchant, category, amount):
             #     """Wrapper to show loading state"""
             #     # Show loading first
@@ -1072,6 +1223,81 @@ Get AI-powered credit card recommendations that maximize your rewards based on:
                 ],
                 inputs=[msg]
             )
+        # ========== Tab: Agent Insights (NEW) ==========
+        with gr.Tab("🤖 Agent Insights"):
+            gr.Markdown("""
+            ## How the Autonomous Agent Works
+            
+            RewardPilot uses **Claude 3.5 Sonnet** as an autonomous agent to provide intelligent card recommendations.
+            
+            ### 🎯 **Phase 1: Planning**
+            The agent analyzes your transaction and decides:
+            - Which microservices to call (Smart Wallet, RAG, Forecast)
+            - In what order to call them
+            - What to optimize for (rewards, caps, benefits)
+            - Confidence level of the plan
+            
+            ### 🤔 **Phase 2: Execution**
+            The agent dynamically:
+            - Calls services based on the plan
+            - Handles failures gracefully
+            - Adapts if services are unavailable
+            - Collects all relevant data
+            
+            ### 🧠 **Phase 3: Reasoning**
+            The agent synthesizes results to:
+            - Explain **why** this card is best
+            - Identify potential risks or warnings
+            - Suggest alternative options
+            - Calculate annual impact
+            
+            ### 📚 **Phase 4: Learning**
+            The agent improves over time by:
+            - Storing past decisions
+            - Learning from user feedback
+            - Adjusting strategies for similar transactions
+            - Building a knowledge base
+            
+            ---
+            
+            ### 🔑 **Key Features**
+            
+            ✅ **Natural Language Explanations** - Understands context like a human  
+            ✅ **Dynamic Planning** - Adapts to your specific situation  
+            ✅ **Confidence Scoring** - Tells you how certain it is  
+            ✅ **Multi-Service Coordination** - Orchestrates 3 microservices  
+            ✅ **Self-Correction** - Learns from mistakes  
+            
+            ---
+            
+            ### 📊 **Example Agent Plan**
+            
+            ```json
+            {
+              "strategy": "Optimize for grocery rewards with cap monitoring",
+              "service_calls": [
+                {"service": "smart_wallet", "priority": 1, "reason": "Get base recommendation"},
+                {"service": "spend_forecast", "priority": 2, "reason": "Check spending caps"},
+                {"service": "rewards_rag", "priority": 3, "reason": "Get detailed benefits"}
+              ],
+              "confidence": 0.92,
+              "expected_outcome": "Recommend Amex Gold for 4x grocery points"
+            }
+            ```
+            
+            ---
+            
+            ### 🎓 **Powered By**
+            - **Model**: Claude 3.5 Sonnet (Anthropic)
+            - **Architecture**: Autonomous Agent Pattern
+            - **Framework**: LangChain + Custom Logic
+            - **Memory**: Redis (for learning)
+            
+            ---
+            
+            **Try it out in the "Get Recommendation" tab!** 🚀
+            """)
+
         # ========== Tab 3: About ==========
         with gr.Tab("ℹ️ About"):
             gr.Markdown(