Update app.py

app.py

@@ -1,64 +1,664 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
 """
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+MCPDB Agentic Exception Determination System
+6-Core Agent Financial Reconciliation with Excel Integration
+Deployed on Hugging Face Spaces with Gradio Interface
 """
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
+import gradio as gr
+import os
+import json
+import logging
+import asyncio
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any, Tuple
+from PIL import Image
+import io
+import uuid
+import threading
+import time
+from collections import defaultdict, deque
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+# Load environment variables
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-    messages.append({"role": "user", "content": message})
+# ---------------------------------------------------------------------------
+# CONSTANTS & CONFIGURATION
+# ---------------------------------------------------------------------------
 
-    response = ""
+AGENT_TYPES = ["custodian", "cash", "trade", "corporate", "orchestrator", "web"]
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+EXCEL_TEMPLATES = {
+    "custodian": {
+        "Portfolio_Positions": ["Security_ID", "Security_Name", "Quantity", "Price", "Market_Value", "Last_Updated"],
+        "Holdings_History": ["Trade_ID", "Security_ID", "Quantity", "Trade_Date", "Settlement_Date", "Status"],
+        "Reconciliation_Check": ["Trade_ID", "Expected", "Actual", "Match", "Exception_Flag"]
+    },
+    "cash": {
+        "Cash_Flows": ["Trade_ID", "Amount", "Currency", "Type", "Date", "Status"],
+        "Account_Balances": ["Account", "Currency", "Available", "Pending", "Total"],
+        "Liquidity_Analysis": ["Date", "Available_Cash", "Pending_Traded", "Net_Cash", "Risk_Level"]
+    },
+    "trade": {
+        "Trade_Feed": ["Trade_ID", "Security_ID", "Side", "Quantity", "Price", "Broker", "Status"],
+        "Settlement_Details": ["Trade_ID", "Expected_Settle", "Actual_Settle", "Paired", "Exception"],
+        "Trade_Verification": ["Field", "Expected", "Actual", "Error", "Resolved"]
+    },
+    "corporate": {
+        "Action_Calendar": ["Security_ID", "Action_Type", "Ex_Date", "Record_Date", "Payment_Date", "Ratio"],
+        "Impact_Analysis": ["Security_ID", "Pre_Quantity", "Post_Quantity", "Impact_Amount"],
+        "Events_Log": ["Event_ID", "Security_ID", "Effective_Date", "Action_Type", "Processed"]
+    },
+    "orchestrator": {
+        "Agent_Status": ["Agent", "Status", "Last_Activity", "Processed_Count", "Error_Count"],
+        "Decision_Log": ["Decision_ID", "Trade_ID", "Agent_Votes", "Final_Decision", "Confidence"],
+        "Exception_Registry": ["Exception_ID", "Type", "Severity", "Status", "Assigned_Agent"]
+    },
+    "web": {
+        "Market_Data": ["Security_ID", "Price", "Volume", "As_Of", "Source"],
+        "News_Feeds": ["Security_ID", "Headline", "Impact", "Published", "Relevance"],
+        "Analyst_Reports": ["Security_ID", "Analyst", "Rating", "Price_Target", "Date"]
+    }
+}
 
-        response += token
-        yield response
+# ---------------------------------------------------------------------------
+# IN-MEMORY STORAGE (for Hugging Face lightweight deployment)
+# ---------------------------------------------------------------------------
 
+class InMemoryStore:
+    def __init__(self):
+        self.trades = defaultdict(dict)
+        self.exceptions = defaultdict(dict)
+        self.agents = {agent_type: {
+            "status": "active",
+            "last_activity": datetime.now(),
+            "processed_count": 0,
+            "error_count": 0,
+            "workbook_data": {}
+        } for agent_type in AGENT_TYPES}
+        self.reconciliation_history = deque(maxlen=1000)
+        self.lock = threading.Lock()
+    
+    def get_next_exception_id(self) -> str:
+        return f"EXC_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
+    
+    def get_next_trade_id(self) -> str:
+        return f"TRD_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+store = InMemoryStore()
+
+# ---------------------------------------------------------------------------
+# AGENT IMPLEMENTATIONS
+# ---------------------------------------------------------------------------
+
+class BaseAgent:
+    def __init__(self, agent_type: str):
+        self.type = agent_type
+        self.logger = logging.getLogger(f"agent.{agent_type}")
+    
+    def process_trade(self, trade_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Process individual trade and return verdict"""
+        raise NotImplementedError
+    
+    def get_status(self) -> Dict[str, Any]:
+        return store.agents[self.type]
+    
+    def update_activity(self):
+        store.agents[self.type]["last_activity"] = datetime.now()
+        store.agents[self.type]["processed_count"] += 1
+
+class CustodianAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("custodian")
+    
+    def process_trade(self, trade: Dict[str, Any]) -> Dict[str, Any]:
+        self.update_activity()
+        
+        # Simulate security verification
+        quantity = trade.get("quantity", 0)
+        security = trade.get("security_id", "")
+        
+        # Check if we have enough positions in our "ledger"        
+        verdict = "PASS" if quantity > 0 else "FAIL: Insufficient positions"
+        
+        return {
+            "verdict": verdict,
+            "details": f"Custodian verification: {quantity} {security} confirmed available",
+            "timestamp": datetime.now().isoformat()
+        }
+
+class CashAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("cash")
+    
+    def process_trade(self, trade: Dict[str, Any]) -> Dict[str, Any]:
+        self.update_activity()
+        
+        amount = trade.get("amount", float(trade.get("quantity", 0)) * float(trade.get("price", 0)))
+        
+        # Simulate cash availability
+        verdict = "PASS" if amount > 0 else "FAIL: Insufficient funds"
+        
+        return {
+            "verdict": verdict,
+            "details": f"Cash verification: ${amount:,.2f} available",
+            "timestamp": datetime.now().isoformat()
+        }
+
+class TradeAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("trade")
+    
+    def process_trade(self, trade: Dict[str, Any]) -> Dict[str, Any]:
+        self.update_activity()
+        
+        # Validate trade data structure
+        required_fields = ["trade_id", "security_id", "quantity", "price"]
+        missing_fields = [f for f in required_fields if not trade.get(f)]
+        
+        verdict = "PASS" if not missing_fields else f"FAIL: Missing required fields: {', '.join(missing_fields)}"
+        
+        return {
+            "verdict": verdict,
+            "details": "Trade file validation completed",
+            "missing_fields": missing_fields,
+            "timestamp": datetime.now().isoformat()
+        }
+
+class CorporateAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("corporate")
+    
+    def process_trade(self, trade: Dict[str, Any]) -> Dict[str, Any]:
+        self.update_activity()
+        
+        # Check for corporate actions affecting this security
+        security_id = trade.get("security_id", "")
+        
+        # Simulate corporate action check
+        corporate_actions = ["stock_split", "dividend", "merger"]
+        impacting_actions = [ca for ca in corporate_actions if ca in str(security_id).lower()]
+        
+        if impacting_actions:
+            verdict = f"REVIEW: Corporate action detected: {', '.join(impacting_actions)}"
+        else:
+            verdict = "PASS: No corporate actions impacting this security"
+        
+        return {
+            "verdict": verdict,
+            "details": f"Corporate action analysis: {verdict}",
+            "timestamp": datetime.now().isoformat()
+        }
+
+class OrchestratorAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("orchestrator")
+        self.agents = {
+            "custodian": CustodianAgent(),
+            "cash": CashAgent(),
+            "trade": TradeAgent(),
+            "corporate": CorporateAgent()
+        }
+    
+    def process_trade(self, trade: Dict[str, Any]) -> Dict[str, Any]:
+        self.update_activity()
+        
+        trade_id = trade.get("trade_id", store.get_next_trade_id())
+        
+        # Get all agent decisions
+        agent_decisions = {}
+        exception_flags = []
+        
+        for agent_name, agent in self.agents.items():
+            decision = agent.process_trade(trade)
+            agent_decisions[agent_name] = decision
+            
+            if "FAIL" in decision["verdict"] or "REVIEW" in decision["verdict"]:
+                exception_flags.append({
+                    "agent": agent_name,
+                    "issue": decision["verdict"],
+                    "details": decision["details"]
+                })
+        
+        # Determine final outcome
+        if exception_flags:
+            exception_id = store.get_next_exception_id()
+            exception = {
+                "id": exception_id,
+                "trade_id": trade_id,
+                "type": "discrepancy",
+                "severity": "high" if any("FAIL" in flag["issue"] for flag in exception_flags) else "medium",
+                "status": "open",
+                "agents": agent_decisions,
+                "created_at": datetime.now().isoformat()
+            }
+            
+            store.exceptions[exception_id] = exception
+            store.reconciliation_history.append({
+                "trade_id": trade_id,
+                "status": "exception",
+                "exception_id": exception_id
+            })
+            
+            result = {
+                "status": "exception",
+                "exception_id": exception_id,
+                "message": f"Reconciliation exception detected: {len(exception_flags)} issues found",
+                "agents": agent_decisions
+            }
+        else:
+            result = {
+                "status": "success",
+                "message": "Trade successfully reconciled - no exceptions",
+                "agents": agent_decisions
+            }
+        
+        store.trades[trade_id] = {
+            "data": trade,
+            "result": result,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        return result
+    
+    def resolve_exception(self, exception_id: str, resolution: Dict[str, Any]) -> Dict[str, Any]:
+        if exception_id not in store.exceptions:
+            return {"error": "Exception not found"}
+        
+        exception = store.exceptions[exception_id]
+        exception["status"] = "resolved"
+        exception["resolution"] = resolution
+        exception["resolved_at"] = datetime.now().isoformat()
+        
+        store.reconciliation_history.append({
+            "exception_id": exception_id,
+            "status": "resolved",
+            "resolution": resolution
+        })
+        
+        return {"success": True, "exception": exception}
+
+class WebAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("web")
+    
+    def fetch_market_data(self, securities: List[str]) -> Dict[str, Any]:
+        self.update_activity()
+        
+        # Simulate real-time market data
+        market_data = {}
+        for security in securities:
+            market_data[security] = {
+                "current_price": 100.0 + (hash(security) % 50),
+                "last_updated": datetime.now().isoformat(),
+                "source": "simulated_web_data"
+            }
+        
+        return {
+            "data": market_data,
+            "source": "web_agent",
+            "timestamp": datetime.now().isoformat()
+        }
+
+# Initialize agents
+orchestrator = OrchestratorAgent()
+web_agent = WebAgent()
+all_agents = {
+    "custodian": CustodianAgent(),
+    "cash": CashAgent(),
+    "trade": TradeAgent(),
+    "corporate": CorporateAgent(),
+    "orchestrator": orchestrator,
+    "web": web_agent
+}
+
+# ---------------------------------------------------------------------------
+# EXCEL WORKBOOK MANAGEMENT
+# ---------------------------------------------------------------------------
+
+class ExcelManager:
+    def __init__(self):
+        self.workbooks_dir = "excel_workbooks"
+        os.makedirs(self.workbooks_dir, exist_ok=True)
+        self.init_workbooks()
+    
+    def init_workbooks(self):
+        """Initialize Excel workbooks for all agents"""
+        for agent_type, sheets in EXCEL_TEMPLATES.items():
+            file_path = f"{self.workbooks_dir}/{agent_type}_agent_workbook.xlsx"
+            if not os.path.exists(file_path):
+                # Create mock Excel file (for demo purposes)
+                try:
+                    import pandas as pd
+                    with pd.ExcelWriter(file_path, engine='openpyxl') as writer:
+                        for sheet_name, columns in sheets.items():
+                            df = pd.DataFrame(columns=columns)
+                            df.to_excel(writer, sheet_name=sheet_name, index=False)
+                except ImportError:
+                    # Fallback: create info file
+                    with open(file_path.replace('.xlsx', '.txt'), 'w') as f:
+                        f.write(f"Excel workbook for {agent_type} agent\n")
+                        for sheet_name, columns in sheets.items():
+                            f.write(f"Sheet: {sheet_name}\n")
+                            f.write(f"Columns: {', '.join(columns)}\n")
+    
+    def get_agent_workbook(self, agent_type: str) -> str:
+        return f"{self.workbooks_dir}/{agent_type}_agent_workbook.xlsx"
+    
+    def list_all_workbooks(self) -> List[Dict[str, Any]]:
+        workbooks = []
+        for agent_type in AGENT_TYPES:
+            path = self.get_agent_workbook(agent_type)
+            if os.path.exists(path):
+                stat = os.stat(path)
+                workbooks.append({
+                    "agent_type": agent_type,
+                    "path": path,
+                    "last_modified": datetime.fromtimestamp(stat.st_mtime).isoformat()
+                })
+        return workbooks
+
+excel_manager = ExcelManager()
+
+# ---------------------------------------------------------------------------
+# GRADIO UI & API FUNCTIONS
+# ---------------------------------------------------------------------------
+
+def submit_trade(
+    security_id: str,
+    quantity: float,
+    price: float,
+    trade_side: str,
+    broker: str,
+    counterparty: str,
+    settlement_date: str
+) -> str:
+    """Submit trade for reconciliation processing"""
+    
+    if not security_id or quantity <= 0 or price <= 0:
+        return json.dumps({"error": "Invalid trade parameters"})
+    
+    trade_data = {
+        "trade_id": store.get_next_trade_id(),
+        "security_id": security_id,
+        "quantity": quantity,
+        "price": price,
+        "trade_side": trade_side,
+        "broker": broker,
+        "counterparty": counterparty,
+        "settlement_date": settlement_date,
+        "amount": quantity * price,
+        "submitted_at": datetime.now().isoformat()
+    }
+    
+    # Process through orchestrator
+    result = orchestrator.process_trade(trade_data)
+    
+    return json.dumps(result, indent=2, default=str)
+
+def get_agent_status(agent_type: str) -> str:
+    """Get status of specific agent"""
+    if agent_type not in all_agents:
+        return json.dumps({"error": f"Unknown agent: {agent_type}"})
+    
+    agent = all_agents[agent_type]
+    return json.dumps(agent.get_status(), indent=2, default=str)
+
+def list_exceptions() -> str:
+    """List all current exceptions"""
+    exceptions = list(store.exceptions.values())
+    return json.dumps(exceptions, indent=2, default=str)
+
+def resolve_exception_manually(
+    exception_id: str,
+    resolution_action: str,
+    justification: str
+) -> str:
+    """Resolve a specific exception"""
+    resolution = {
+        "action": resolution_action,
+        "justification": justification,
+        "resolved_by": "manual"
+    }
+    
+    result = orchestrator.resolve_exception(exception_id, resolution)
+    return json.dumps(result, indent=2, default=str)
+
+def get_dashboard() -> str:
+    """Get system dashboard data"""
+    dashboard = {
+        "summary": {
+            "total_trades": len(store.trades),
+            "open_exceptions": len([e for e in store.exceptions.values() if e["status"] == "open"]),
+            "resolved_exceptions": len([e for e in store.exceptions.values() if e["status"] == "resolved"]),
+            "last_activity": max(trade["timestamp"] for trade in store.trades.values()) if store.trades else None
+        },
+        "agents": {
+            agent_type: agent.get_status()
+            for agent_type, agent in all_agents.items()
+        },
+        "recent_exceptions": list(store.reconciliation_history)[-10:]
+    }
+    return json.dumps(dashboard, indent=2, default=str)
+
+# Demo scenario functions
+def demo_normal_settlement() -> str:
+    """Demo: Normal perfect reconciliation"""
+    trade = {
+        "security_id": "AAPL",
+        "quantity": 100,
+        "price": 150.0,
+        "trade_side": "BUY",
+        "broker": "GOLD",
+        "counterparty": "MORG",
+        "settlement_date": datetime.now().strftime("%Y-%m-%d"),
+        "amount": 15000.0
+    }
+    
+    trade["trade_id"] = store.get_next_trade_id()
+    return json.dumps(orchestrator.process_trade(trade), indent=2, default=str)
+
+def demo_failed_trade() -> str:
+    """Demo: Failed trade due to insufficient funds"""
+    trade = {
+        "security_id": "TSLA",
+        "quantity": 50000,
+        "price": 1000.0,  # Too large amount
+        "trade_side": "BUY",
+        "broker": "BROK",
+        "counterparty": "COLL",
+        "settlement_date": datetime.now().strftime("%Y-%m-%d"),
+        "amount": 50000000.0
+    }
+    
+    trade["trade_id"] = store.get_next_trade_id()
+    return json.dumps(orchestrator.process_trade(trade), indent=2, default=str)
+
+def demo_corporate_action() -> str:
+    """Demo: Apple stock split scenario"""
+    trade = {
+        "security_id": "AAPL_SPLIT",
+        "quantity": 1000,
+        "price": 175.0,
+        "trade_side": "SELL",
+        "broker": "SPLLIT",
+        "counterparty": "BUYER",
+        "settlement_date": datetime.now().strftime("%Y-%m-%d"),
+        "amount": 175000.0
+    }
+    
+    trade["trade_id"] = store.get_next_trade_id()
+    return json.dumps(orchestrator.process_trade(trade), indent=2, default=str)
+
+def get_excel_workbook(agent_type: str) -> str:
+    """Get Excel workbook for agent"""
+    return json.dumps({
+        "workbook_path": excel_manager.get_agent_workbook(agent_type),
+        "exists": os.path.exists(excel_manager.get_agent_workbook(agent_type))
+    })
+
+# ---------------------------------------------------------------------------
+# GRADIO INTERFACE
+# ---------------------------------------------------------------------------
+
+def create_gradio_interface() -> gr.Blocks:
+    """Create the Gradio interface"""
+    
+    with gr.Blocks(title="MCPDB Agentic Exception Determination", theme=gr.themes.Soft()) as app:
+        gr.Markdown("""
+        # 🏦 MCPDB Agentic Exception Determination System
+        ### 6-Core Agent Financial Reconciliation with Excel Integration
+        
+        **Deployed on Hugging Face Spaces with built-in Excel MCP Server support**
+        """)
+        
+        # Main interface
+        with gr.Tabs():
+            
+            # Reconciliation Tab
+            with gr.Tab("🔍 Trade Reconciliation"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Submit New Trade")
+                        
+                        security_id = gr.Textbox(label="Security ID", value="AAPL")
+                        quantity = gr.Number(label="Quantity", value=100)
+                        price = gr.Number(label="Price", value=150.0)
+                        trade_side = gr.Dropdown(
+                            choices=["BUY", "SELL"],
+                            value="BUY",
+                            label="Trade Side"
+                        )
+                        broker = gr.Textbox(label="Broker", value="GOLD")
+                        counterparty = gr.Textbox(label="Counterparty", value="MORG")
+                        settlement_date = gr.Textbox(
+                            label="Settlement Date", 
+                            value=datetime.now().strftime("%Y-%m-%d")
+                        )
+                        
+                        submit_btn = gr.Button("🔄 Submit for Reconciliation", variant="primary")
+                        
+                        gr.Markdown("### Demo Scenarios")
+                        demo_normal_btn = gr.Button("🎯 Normal Settlement", size="sm")
+                        demo_failed_btn = gr.Button("💥 Failed Trade", size="sm")
+                        demo_corp_btn = gr.Button("🍎 Corporate Action", size="sm")
+                        
+                        result_output = gr.JSON(label="Reconciliation Result")
+            
+            # Exceptions Tab
+            with gr.Tab("⚠️ Exceptions"):
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("#### Current Exceptions")
+                        exceptions_output = gr.JSON(label="Open Exceptions")
+                        refresh_exceptions_btn = gr.Button("🔄 Refresh Exceptions")
+                    
+                    with gr.Column():
+                        gr.Markdown("#### Resolve Exception")
+                        exception_id_input = gr.Textbox(label="Exception ID")
+                        resolution_action = gr.Dropdown(
+                            choices=["APPROVE", "REJECT", "REVIEW", "ESCALATE"],
+                            value="APPROVE",
+                            label="Resolution Action"
+                        )
+                        justification = gr.Textbox(
+                            label="Justification", 
+                            value="Manual review and approval provided"
+                        )
+                        resolve_btn = gr.Button("✅ Resolve Exception")
+                        
+                        resolution_output = gr.JSON(label="Resolution Result")
+            
+            # Agents Tab
+            with gr.Tab("🤖 Agents"):
+                gr.Markdown("### Agent Status Dashboard")
+                
+                agent_monitor = gr.JSON(label="Agent Status")
+                refresh_agents_btn = gr.Button("🔄 Refresh Agent Status")
+                
+                with gr.Row():
+                    for agent in AGENT_TYPES:
+                        btn = gr.Button(f"Status: {agent.title()}")
+                        btn.click(fn=lambda a=agent: get_agent_status(a), outputs=agent_monitor)
+            
+            # Excel Tab
+            with gr.Tab("📊 Excel Integration"):
+                gr.Markdown("### Agent Excel Workbooks")
+                
+                workbooks_list = gr.JSON(label="Agent Workbooks")
+                refresh_workbooks_btn = gr.Button("🔄 Refresh Workbooks")
+                
+                with gr.Row():
+                    for agent_type in AGENT_TYPES:
+                        btn = gr.Button(f"📋 {agent_type.title()}")
+                        btn.click(lambda a=agent_type: get_excel_workbook(a), outputs=None)
+                        btn.style = "secondary"
+            
+            # Dashboard Tab
+            with gr.Tab("📈 Dashboard"):
+                gr.Markdown("### System Dashboard")
+                dashboard_output = gr.JSON(label="Dashboard Data")
+                refresh_dashboard_btn = gr.Button("🔄 Refresh Dashboard")
+        
+        gr.Markdown("---")
+        gr.Markdown(f"""
+        <div style='text-align: center; color: #666; font-size: 0.9rem; padding: 20px;'>
+            <p>🏦 MCPDB Agentic Exception Determination System v1.0</p>
+            <p>6-Core Agents: Custodian | Cash | Trade | Corporate | Orchestrator | Web</p>
+            <p>Built for Hugging Face Spaces with Excel MCP Server Integration</p>
+            <p>Agent Status: {' | '.join([f'{a.title()}: {store.agents[a]["status"]}' for a in AGENT_TYPES])}</p>
+        </div>
+        """)
+        
+        # Event handlers
+        submit_btn.click(
+            fn=submit_trade,
+            inputs=[security_id, quantity, price, trade_side, broker, counterparty, settlement_date],
+            outputs=[result_output]
+        )
+        
+        # Demo scenarios
+        demo_normal_btn.click(fn=demo_normal_settlement, outputs=[result_output])
+        demo_failed_btn.click(fn=demo_failed_trade, outputs=[result_output])
+        demo_corp_btn.click(fn=demo_corporate_action, outputs=[result_output])
+        
+        refresh_exceptions_btn.click(fn=list_exceptions, outputs=[exceptions_output])
+        refresh_agents_btn.click(fn=get_dashboard, outputs=[agent_monitor])
+        refresh_dashboard_btn.click(fn=get_dashboard, outputs=[dashboard_output])
+        refresh_workbooks_btn.click(fn=excel_manager.list_all_workbooks, outputs=[workbooks_list])
+        resolve_btn.click(
+            fn=resolve_exception_manually,
+            inputs=[exception_id_input, resolution_action, justification],
+            outputs=[resolution_output]
+        )
+        
+        # Initial loads
+        app.load(fn=list_exceptions, outputs=[exceptions_output])
+        app.load(fn=get_dashboard, outputs=[dashboard_output])
+        app.load(fn=excel_manager.list_all_workbooks, outputs=[workbooks_list])
+        
+    return app
 
+# ---------------------------------------------------------------------------
+# LAUNCH
+# ---------------------------------------------------------------------------
 
 if __name__ == "__main__":
-    demo.launch()
+    app = create_gradio_interface()
+    
+    # Initialize with some demo data
+    logger.info("🚀 Starting MCPDB Agentic Exception Determination System")
+    logger.info(f"🔗 Agents Initialized: {', '.join(AGENT_TYPES)}")
+    logger.info("📊 Excel workbooks created for all agents")
+    logger.info("🎯 Demo scenarios ready for testing")
+    
+    app.launch(server_name="0.0.0.0", server_port=8080, share=True)