Update app.py

app.py

@@ -1,27 +1,872 @@
-gradio>=4.0.0
-pandas>=1.5.0
-numpy>=1.24.0
-pyautogen>=0.2.0
-openai>=1.0.0
-tavily-python>=0.3.0
-plotly>=5.17.0
-matplotlib>=3.7.0
-seaborn>=0.12.0
-openpyxl>=3.1.0
-xlrd>=2.0.0
-PyPDF2>=3.0.0
-python-docx>=0.8.11
-python-pptx>=0.6.21
-requests>=2.31.0
-beautifulsoup4>=4.12.0
-lxml>=4.9.0
-python-dateutil>=2.8.0
-pytz>=2023.3
-scikit-learn>=1.3.0
-scipy>=1.11.0
-networkx>=3.1
-asyncio-throttle>=1.0.2
-aiohttp>=3.8.0
-pydantic>=2.0.0
-diskcache>=5.6.0
-joblib>=1.3.0
+import os
+import json
+import pandas as pd
+import gradio as gr
+from typing import Annotated, Dict, List, Any
+from tavily import TavilyClient
+from autogen import AssistantAgent, UserProxyAgent, register_function, Cache
+from autogen.agentchat import GroupChat, GroupChatManager
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime
+import asyncio
+import threading
+import time
+import io
+import docx
+from pptx import Presentation
+import PyPDF2
+
+# Disable Docker globally
+os.environ["AUTOGEN_USE_DOCKER"] = "0"
+
+class SupplyChainOptimizer:
+    def __init__(self):
+        # Initialize API keys from environment variables
+        self.openai_api_key = os.environ.get("OPENAI_API_KEY") or os.environ.get("OPENAI_KEY")
+        self.tavily_api_key = os.environ.get("TAVILY_API_KEY") or os.environ.get("TAVILY_KEY")
+        
+        # For development/testing, allow demo mode
+        self.demo_mode = False
+        if not self.openai_api_key or not self.tavily_api_key:
+            print("API keys not found. Running in demo mode.")
+            self.demo_mode = True
+            self.openai_api_key = "demo-key"
+            self.tavily_api_key = "demo-key"
+        
+        # Initialize Tavily client (only if not in demo mode)
+        if not self.demo_mode:
+            try:
+                self.tavily = TavilyClient(api_key=self.tavily_api_key)
+            except Exception as e:
+                print(f"Error initializing Tavily: {e}")
+                self.demo_mode = True
+        
+        # Initialize agents
+        self._setup_agents()
+        
+        # Store results
+        self.latest_analysis = ""
+        self.latest_optimization = ""
+        self.search_results = ""
+
+    def _setup_agents(self):
+        """Setup AutoGen agents"""
+        self.user_proxy = UserProxyAgent(
+            name="UserProxy",
+            system_message="You are the user interacting with the agents.",
+            human_input_mode="NEVER",
+            code_execution_config={"work_dir": "code", "use_docker": False},
+        )
+
+        # Only setup LLM agents if not in demo mode
+        if not self.demo_mode:
+            self.reasoning_agent = AssistantAgent(
+                name="ReasoningAgent",
+                llm_config={"config_list": [{"model": "gpt-3.5-turbo", "api_key": self.openai_api_key}]},
+                system_message="""You are an expert supply chain analyst. Analyze forecast data using real-time search results.
+                Evaluate if forecasts are reasonable based on current market conditions, events, and trends.
+                Provide detailed reasoning and recommendations. Format your response clearly with proper structure and avoid using asterisks for emphasis."""
+            )
+
+            self.optimization_agent = AssistantAgent(
+                name="OptimizationAgent",
+                llm_config={"config_list": [{"model": "gpt-3.5-turbo", "api_key": self.openai_api_key}]},
+                system_message="""You are a supply chain optimization expert. Create detailed redistribution plans.
+                Consider costs, travel time, inventory levels, and demand forecasts.
+                Provide step-by-step optimization plans with clear recommendations and cost analysis. Use professional formatting without asterisks."""
+            )
+
+            # Register search tool
+            register_function(
+                self.tavily_search_tool,
+                caller=self.reasoning_agent,
+                executor=self.user_proxy,
+                name="tavily_search_tool",
+                description="Conducts real-time market research using Tavily."
+            )
+        else:
+            self.reasoning_agent = None
+            self.optimization_agent = None
+
+    def tavily_search_tool(self, query: Annotated[str, "Market Research Query"]) -> Annotated[str, "Search results"]:
+        """Search tool using Tavily API"""
+        if self.demo_mode:
+            return f"Demo Mode: Search query '{query}' - Market conditions show stable tourism activity with moderate demand fluctuations in the specified regions."
+        
+        try:
+            results = self.tavily.get_search_context(query=query, search_depth="advanced")
+            self.search_results = results
+            return results
+        except Exception as e:
+            return f"Search error: {str(e)}"
+
+    def parse_file_content(self, file_path, file_type):
+        """Parse various file formats and extract data"""
+        try:
+            if file_type == "excel":
+                # Try to read Excel file
+                df = pd.read_excel(file_path, sheet_name=None)
+                return self._process_excel_data(df)
+            elif file_type == "csv":
+                df = pd.read_csv(file_path)
+                return self._process_csv_data(df)
+            elif file_type == "pdf":
+                return self._process_pdf_data(file_path)
+            elif file_type == "word":
+                return self._process_word_data(file_path)
+            elif file_type == "ppt":
+                return self._process_ppt_data(file_path)
+            else:
+                return "Unsupported file format"
+        except Exception as e:
+            return f"Error processing file: {str(e)}"
+
+    def _process_excel_data(self, excel_data):
+        """Process Excel data and extract forecast, inventory, and route information"""
+        processed_data = {
+            'forecast': [],
+            'inventory': [],
+            'routes': []
+        }
+        
+        for sheet_name, df in excel_data.items():
+            if 'forecast' in sheet_name.lower():
+                processed_data['forecast'] = df.to_dict('records')
+            elif 'inventory' in sheet_name.lower():
+                processed_data['inventory'] = df.to_dict('records')
+            elif 'route' in sheet_name.lower():
+                processed_data['routes'] = df.to_dict('records')
+        
+        return processed_data
+
+    def _process_csv_data(self, df):
+        """Process CSV data"""
+        return {'data': df.to_dict('records')}
+
+    def _process_pdf_data(self, file_path):
+        """Extract text from PDF"""
+        try:
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                text = ""
+                for page in pdf_reader.pages:
+                    text += page.extract_text()
+                return {'text': text}
+        except Exception as e:
+            return f"Error reading PDF: {str(e)}"
+
+    def _process_word_data(self, file_path):
+        """Extract text from Word document"""
+        try:
+            doc = docx.Document(file_path)
+            text = ""
+            for paragraph in doc.paragraphs:
+                text += paragraph.text + "\n"
+            return {'text': text}
+        except Exception as e:
+            return f"Error reading Word document: {str(e)}"
+
+    def _process_ppt_data(self, file_path):
+        """Extract text from PowerPoint"""
+        try:
+            prs = Presentation(file_path)
+            text = ""
+            for slide in prs.slides:
+                for shape in slide.shapes:
+                    if hasattr(shape, "text"):
+                        text += shape.text + "\n"
+            return {'text': text}
+        except Exception as e:
+            return f"Error reading PowerPoint: {str(e)}"
+
+    def create_forecast_visualization(self, forecast_data):
+        """Create interactive forecast visualization with vibrant colors"""
+        df = pd.DataFrame(forecast_data)
+        
+        fig = go.Figure()
+        
+        # Vibrant color palette
+        colors = ['#FF6B35', '#F7931E', '#FFD23F', '#06FFA5', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7', '#DDA0DD', '#FA8072']
+        
+        for i, (city, group) in enumerate(df.groupby('City')):
+            fig.add_trace(go.Bar(
+                name=city,
+                x=group['Product'],
+                y=group['Forecasted_Demand'],
+                marker_color=colors[i % len(colors)],
+                text=group['Forecasted_Demand'],
+                textposition='auto',
+                textfont=dict(size=14, color='white', family='Arial Black'),
+            ))
+        
+        fig.update_layout(
+            title={
+                'text': "Demand Forecast by City & Product",
+                'x': 0.5,
+                'xanchor': 'center',
+                'font': {'size': 20, 'color': '#B8860B', 'family': 'Arial Black'}
+            },
+            xaxis_title="Products",
+            yaxis_title="Forecasted Demand",
+            xaxis=dict(titlefont=dict(size=16, color='#8B4513', family='Arial Black')),
+            yaxis=dict(titlefont=dict(size=16, color='#8B4513', family='Arial Black')),
+            barmode='group',
+            plot_bgcolor='rgba(255,248,220,0.9)',
+            paper_bgcolor='rgba(255,248,220,0.9)',
+            font=dict(color='#8B4513', size=12, family='Arial'),
+            height=500,
+            legend=dict(font=dict(size=12, color='#8B4513', family='Arial'))
+        )
+        
+        return fig
+
+    def create_inventory_chart(self, inventory_data, forecast_data):
+        """Create inventory vs demand comparison with vibrant styling"""
+        inv_df = pd.DataFrame(inventory_data)
+        fore_df = pd.DataFrame(forecast_data)
+        
+        # Merge data
+        merged = pd.merge(inv_df, fore_df, on=['City', 'Product'], how='outer')
+        merged = merged.fillna(0)
+        
+        fig = go.Figure()
+        
+        fig.add_trace(go.Bar(
+            name='Current Stock',
+            x=[f"{row['City']} - {row['Product']}" for _, row in merged.iterrows()],
+            y=merged['Stock_Level'],
+            marker_color='#FF4757',
+            opacity=0.9,
+            text=merged['Stock_Level'],
+            textposition='auto',
+            textfont=dict(size=12, color='white', family='Arial Black')
+        ))
+        
+        fig.add_trace(go.Bar(
+            name='Forecasted Demand',
+            x=[f"{row['City']} - {row['Product']}" for _, row in merged.iterrows()],
+            y=merged['Forecasted_Demand'],
+            marker_color='#FFA502',
+            opacity=0.9,
+            text=merged['Forecasted_Demand'],
+            textposition='auto',
+            textfont=dict(size=12, color='white', family='Arial Black')
+        ))
+        
+        fig.update_layout(
+            title={
+                'text': "Inventory vs Demand Analysis",
+                'x': 0.5,
+                'xanchor': 'center',
+                'font': {'size': 20, 'color': '#B8860B', 'family': 'Arial Black'}
+            },
+            xaxis_title="City & Product",
+            yaxis_title="Units",
+            xaxis=dict(titlefont=dict(size=16, color='#8B4513', family='Arial Black')),
+            yaxis=dict(titlefont=dict(size=16, color='#8B4513', family='Arial Black')),
+            barmode='group',
+            plot_bgcolor='rgba(255,248,220,0.9)',
+            paper_bgcolor='rgba(255,248,220,0.9)',
+            font=dict(color='#8B4513', size=12, family='Arial'),
+            height=500,
+            legend=dict(font=dict(size=12, color='#8B4513', family='Arial'))
+        )
+        
+        return fig
+
+    def create_route_network(self, route_data):
+        """Create route network visualization with vibrant colors"""
+        df = pd.DataFrame(route_data)
+        
+        fig = go.Figure()
+        
+        fig.add_trace(go.Scatter(
+            x=df['Distance_km'],
+            y=df['Cost_per_km'],
+            mode='markers+text',
+            marker=dict(
+                size=[cost*2 for cost in df['Cost_per_km']],
+                color=df['Average_Travel_Time_hrs'],
+                colorscale=[[0, '#FFD700'], [0.5, '#FF6347'], [1, '#DC143C']],
+                showscale=True,
+                colorbar=dict(title="Travel Time (hrs)", titlefont=dict(size=14, color='#8B4513', family='Arial Black'))
+            ),
+            text=[f"{row['Source']} → {row['Destination']}" for _, row in df.iterrows()],
+            textposition="top center",
+            textfont=dict(size=12, color='#8B0000', family='Arial Black'),
+            name="Routes"
+        ))
+        
+        fig.update_layout(
+            title={
+                'text': "Route Analysis: Distance vs Cost",
+                'x': 0.5,
+                'xanchor': 'center',
+                'font': {'size': 20, 'color': '#B8860B', 'family': 'Arial Black'}
+            },
+            xaxis_title="Distance (km)",
+            yaxis_title="Cost per km (₹)",
+            xaxis=dict(titlefont=dict(size=16, color='#8B4513', family='Arial Black')),
+            yaxis=dict(titlefont=dict(size=16, color='#8B4513', family='Arial Black')),
+            plot_bgcolor='rgba(255,248,220,0.9)',
+            paper_bgcolor='rgba(255,248,220,0.9)',
+            font=dict(color='#8B4513', size=12, family='Arial'),
+            height=500
+        )
+        
+        return fig
+
+    def optimize_supply_chain(self, forecast_data, inventory_data, route_data, search_query, progress=gr.Progress()):
+        """Main optimization function"""
+        progress(0.1, desc="Conducting market research...")
+        
+        # Conduct search
+        search_results = self.tavily_search_tool(search_query)
+        
+        progress(0.3, desc="Analyzing forecast data...")
+        
+        if self.demo_mode:
+            time.sleep(2)
+            progress(0.6, desc="Optimizing redistribution plan...")
+            
+            self.latest_analysis = """
+DEMO MODE - Market Analysis & Forecast Reasoning
+
+Market Conditions Assessment:
+- Current tourism trends show moderate activity in hill stations
+- Seasonal demand patterns indicate December is peak season for tourist destinations
+- Economic indicators suggest stable consumer spending on FMCG products
+
+Forecast Accuracy Evaluation:
+- Goa: Forecasted demand of 1,500 units appears reasonable given tourist influx
+- Coorg: 700 units forecast aligns with typical seasonal patterns
+- Mahabaleshwar: 1,000 units seems appropriate for weekend destination
+- Lonavala: 850 units matches proximity to major cities
+- Ooty: 400 units may be conservative given popularity
+
+Risk Factors:
+- Weather conditions could impact transportation
+- Festival seasons may create demand spikes
+- Competition from local suppliers
+
+Recommendations:
+- Monitor real-time booking data
+- Prepare for demand fluctuations
+- Consider safety stock adjustments
+
+Note: Set your API keys to get real-time market intelligence
+            """
+            
+            time.sleep(2)
+            progress(0.8, desc="Generating insights...")
+            
+            self.latest_optimization = """
+DEMO MODE - Optimized Redistribution Plan
+
+Priority Actions:
+
+1. Immediate Redistribution (Week 1)
+   - Move 300 Biscuit units from Lonavala to Coorg (Cost: ₹6,480)
+   - Route: Lonavala → Goa → Coorg (Total: 1,000 km)
+   - Expected delivery: 17 hours
+
+2. Strategic Rebalancing (Week 2)
+   - Reduce Goa soap inventory by 500 units
+   - Distribute to Mahabaleshwar and Ooty based on demand
+   - Utilize cost-effective Goa → Ooty route (₹16,500)
+
+3. Cost Optimization Strategies
+   - Consolidate shipments to reduce per-km costs
+   - Use off-peak travel times for better rates
+   - Implement just-in-time delivery schedules
+
+4. Expected Outcomes
+   - Total redistribution cost: ₹45,000
+   - Inventory optimization: 15% reduction in carrying costs
+   - Service level improvement: 98% demand fulfillment
+   - Risk mitigation: 20% safety stock maintained
+
+5. Timeline & Priorities
+   - High Priority: Coorg biscuits shortage (2 days)
+   - Medium Priority: Ooty soap rebalancing (1 week)
+   - Low Priority: General inventory optimization (2 weeks)
+
+Cost-Benefit Analysis:
+- Investment: ₹45,000 in transportation
+- Savings: ₹65,000 in carrying costs + lost sales prevention
+- Net Benefit: ₹20,000 + improved customer satisfaction
+
+Note: Set your API keys for AI-powered optimization with real market data
+            """
+            
+        else:
+            # Real AI agent processing (similar structure but without asterisks in system messages)
+            reasoning_prompt = f"""
+            Analyze the forecast data against the real-time search results and evaluate if the forecast is reasonable.
+            
+            Forecast Data: {json.dumps(forecast_data, indent=2)}
+            Search Results: {search_results}
+            
+            Please provide detailed reasoning on:
+            1. Market conditions affecting demand
+            2. External factors from search results
+            3. Forecast accuracy assessment
+            4. Risk factors to consider
+            
+            Please format your response professionally without using asterisks for emphasis.
+            """
+            
+            try:
+                with Cache.disk(cache_seed=42) as cache:
+                    reasoning_result = self.user_proxy.initiate_chat(
+                        self.reasoning_agent,
+                        message=reasoning_prompt,
+                        cache=cache,
+                        max_turns=1
+                    )
+                    
+                    if reasoning_result and reasoning_result.chat_history:
+                        self.latest_analysis = reasoning_result.chat_history[-1]['content']
+                    else:
+                        self.latest_analysis = "Analysis completed but no detailed response received."
+            
+            except Exception as e:
+                self.latest_analysis = f"Analysis error: {str(e)}"
+            
+            progress(0.6, desc="Optimizing redistribution plan...")
+            
+            # Optimization phase
+            optimization_prompt = f"""
+            Create an optimized redistribution plan using the analyzed data.
+            
+            Forecast Data: {json.dumps(forecast_data, indent=2)}
+            Inventory Data: {json.dumps(inventory_data, indent=2)}
+            Route Data: {json.dumps(route_data, indent=2)}
+            
+            Analysis Context: {self.latest_analysis}
+            
+            Please provide:
+            1. Redistribution recommendations
+            2. Cost optimization strategies
+            3. Risk mitigation plans
+            4. Timeline and priorities
+            5. Expected cost savings
+            
+            Please format your response professionally without using asterisks for emphasis.
+            """
+            
+            try:
+                with Cache.disk(cache_seed=43) as cache:
+                    optimization_result = self.user_proxy.initiate_chat(
+                        self.optimization_agent,
+                        message=optimization_prompt,
+                        cache=cache,
+                        max_turns=1
+                    )
+                    
+                    if optimization_result and optimization_result.chat_history:
+                        self.latest_optimization = optimization_result.chat_history[-1]['content']
+                    else:
+                        self.latest_optimization = "Optimization completed but no detailed response received."
+            
+            except Exception as e:
+                self.latest_optimization = f"Optimization error: {str(e)}"
+        
+        progress(1.0, desc="Optimization complete!")
+        
+        return self.latest_analysis, self.latest_optimization, search_results
+
+# Initialize the optimizer
+try:
+    optimizer = SupplyChainOptimizer()
+    startup_message = "Supply Chain Optimizer initialized successfully!"
+    if optimizer.demo_mode:
+        startup_message = "Running in DEMO mode. Set API keys for full functionality."
+except Exception as e:
+    print(f"Error initializing optimizer: {e}")
+    class DemoOptimizer:
+        def __init__(self):
+            self.demo_mode = True
+        
+        def create_forecast_visualization(self, data):
+            return go.Figure().add_annotation(text="Set API keys to enable charts")
+        
+        def create_inventory_chart(self, inv, fore):
+            return go.Figure().add_annotation(text="Set API keys to enable charts")
+        
+        def create_route_network(self, routes):
+            return go.Figure().add_annotation(text="Set API keys to enable charts")
+        
+        def optimize_supply_chain(self, f, i, r, q, progress=None):
+            return "Demo mode", "Demo mode", "Demo mode"
+        
+        def parse_file_content(self, path, file_type):
+            return "Demo mode"
+    
+    optimizer = DemoOptimizer()
+    startup_message = "Running in minimal demo mode due to initialization error."
+
+# Default data
+DEFAULT_FORECAST = [
+    {"City": "Goa", "Product": "Soap", "Forecasted_Demand": 1500, "Month": "December"},
+    {"City": "Coorg", "Product": "Biscuits", "Forecasted_Demand": 700, "Month": "December"},
+    {"City": "Mahabaleshwar", "Product": "Soap", "Forecasted_Demand": 1000, "Month": "December"},
+    {"City": "Lonavala", "Product": "Biscuits", "Forecasted_Demand": 850, "Month": "December"},
+    {"City": "Ooty", "Product": "Soap", "Forecasted_Demand": 400, "Month": "December"}
+]
+
+DEFAULT_INVENTORY = [
+    {"City": "Goa", "Product": "Soap", "Stock_Level": 2000},
+    {"City": "Coorg", "Product": "Biscuits", "Stock_Level": 400},
+    {"City": "Mahabaleshwar", "Product": "Soap", "Stock_Level": 1100},
+    {"City": "Lonavala", "Product": "Biscuits", "Stock_Level": 800},
+    {"City": "Ooty", "Product": "Soap", "Stock_Level": 500}
+]
+
+DEFAULT_ROUTES = [
+    {"Source": "Goa", "Destination": "Coorg", "Distance_km": 550, "Cost_per_km": 20, "Average_Travel_Time_hrs": 10},
+    {"Source": "Goa", "Destination": "Ooty", "Distance_km": 750, "Cost_per_km": 22, "Average_Travel_Time_hrs": 15},
+    {"Source": "Coorg", "Destination": "Goa", "Distance_km": 550, "Cost_per_km": 20, "Average_Travel_Time_hrs": 10},
+    {"Source": "Coorg", "Destination": "Mahabaleshwar", "Distance_km": 400, "Cost_per_km": 18, "Average_Travel_Time_hrs": 8},
+    {"Source": "Lonavala", "Destination": "Goa", "Distance_km": 450, "Cost_per_km": 19, "Average_Travel_Time_hrs": 7},
+    {"Source": "Ooty", "Destination": "Coorg", "Distance_km": 800, "Cost_per_km": 21, "Average_Travel_Time_hrs": 16}
+]
+
+def process_files_and_optimize(forecast_file, inventory_file, routes_file, text_input, search_query):
+    """Process uploaded files and text input for optimization"""
+    try:
+        forecast_data = DEFAULT_FORECAST
+        inventory_data = DEFAULT_INVENTORY
+        route_data = DEFAULT_ROUTES
+        
+        # Process uploaded files
+        file_contents = []
+        
+        if forecast_file:
+            file_ext = forecast_file.name.split('.')[-1].lower()
+            if file_ext in ['xlsx', 'xls']:
+                content = optimizer.parse_file_content(forecast_file.name, 'excel')
+                if 'forecast' in content:
+                    forecast_data = content['forecast']
+                file_contents.append(f"Forecast file processed: {forecast_file.name}")
+            elif file_ext == 'csv':
+                df = pd.read_csv(forecast_file.name)
+                forecast_data = df.to_dict('records')
+                file_contents.append(f"Forecast CSV processed: {forecast_file.name}")
+        
+        if inventory_file:
+            file_ext = inventory_file.name.split('.')[-1].lower()
+            if file_ext in ['xlsx', 'xls']:
+                content = optimizer.parse_file_content(inventory_file.name, 'excel')
+                if 'inventory' in content:
+                    inventory_data = content['inventory']
+                file_contents.append(f"Inventory file processed: {inventory_file.name}")
+            elif file_ext == 'csv':
+                df = pd.read_csv(inventory_file.name)
+                inventory_data = df.to_dict('records')
+                file_contents.append(f"Inventory CSV processed: {inventory_file.name}")
+        
+        if routes_file:
+            file_ext = routes_file.name.split('.')[-1].lower()
+            if file_ext in ['xlsx', 'xls']:
+                content = optimizer.parse_file_content(routes_file.name, 'excel')
+                if 'routes' in content:
+                    route_data = content['routes']
+                file_contents.append(f"Routes file processed: {routes_file.name}")
+            elif file_ext == 'csv':
+                df = pd.read_csv(routes_file.name)
+                route_data = df.to_dict('records')
+                file_contents.append(f"Routes CSV processed: {routes_file.name}")
+        
+        # Process text input if provided
+        if text_input and text_input.strip():
+            file_contents.append(f"Text input processed: {len(text_input)} characters")
+        
+        # Create visualizations
+        forecast_chart = optimizer.create_forecast_visualization(forecast_data)
+        inventory_chart = optimizer.create_inventory_chart(inventory_data, forecast_data)
+        route_chart = optimizer.create_route_network(route_data)
+        
+        # Run optimization
+        analysis, optimization, search_results = optimizer.optimize_supply_chain(
+            forecast_data, inventory_data, route_data, search_query
+        )
+        
+        # Processing summary
+        processing_summary = "Files processed:\n" + "\n".join(file_contents) if file_contents else "Using default data"
+        
+        return (
+            forecast_chart,
+            inventory_chart, 
+            route_chart,
+            analysis,
+            optimization,
+            search_results[:2000] + "..." if len(search_results) > 2000 else search_results,
+            processing_summary
+        )
+        
+    except Exception as e:
+        error_msg = f"Processing error: {str(e)}"
+        return None, None, None, error_msg, error_msg, error_msg, error_msg
+
+# Create Gradio interface with updated warm color scheme
+custom_css = """
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+.gradio-container {
+    font-family: 'Inter', sans-serif;
+    background: linear-gradient(135deg, #FFF8DC 0%, #FFEBCD 100%);
+    min-height: 100vh;
+}
+
+.main-header {
+    text-align: center;
+    background: linear-gradient(135deg, #DC143C 0%, #FF6347 50%, #FFD700 100%);
+    color: white;
+    padding: 2.5rem;
+    border-radius: 15px;
+    margin-bottom: 2rem;
+    box-shadow: 0 8px 25px rgba(220, 20, 60, 0.3);
+    border: 2px solid #B8860B;
+}
+
+.main-header h1 {
+    font-size: 2.5rem;
+    font-weight: 700;
+    margin-bottom: 1rem;
+    text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+}
+
+.main-header p {
+    font-size: 1.1rem;
+    font-weight: 500;
+    text-shadow: 1px 1px 2px rgba(0,0,0,0.2);
+}
+
+.section-header {
+    background: linear-gradient(90deg, #FF4757 0%, #FFA502 100%);
+    color: white;
+    padding: 1.2rem;
+    border-radius: 10px;
+    margin: 1rem 0;
+    text-align: center;
+    font-weight: 600;
+    font-size: 1.1rem;
+    text-shadow: 1px 1px 2px rgba(0,0,0,0.2);
+    border: 2px solid #B8860B;
+    box-shadow: 0 4px 15px rgba(255, 71, 87, 0.2);
+}
+
+.results-container {
+    background: linear-gradient(135deg, #FFFACD 0%, #F5DEB3 100%);
+    padding: 2rem;
+    border-radius: 12px;
+    margin: 1rem 0;
+    box-shadow: 0 4px 20px rgba(184, 134, 11, 0.15);
+    border: 2px solid #DAA520;
+}
+
+.footer {
+    text-align: center;
+    color: #8B4513;
+    padding: 2rem;
+    border-top: 2px solid #DAA520;
+    margin-top: 2rem;
+    background: linear-gradient(135deg, #FFF8DC 0%, #FFEBCD 100%);
+    border-radius: 10px;
+    font-weight: 500;
+}
+
+.upload-area {
+    border: 3px dashed #DAA520;
+    border-radius: 10px;
+    padding: 1.5rem;
+    margin: 0.5rem 0;
+    background: linear-gradient(135deg, #FFFACD 0%, #F0E68C 100%);
+    transition: all 0.3s ease;
+}
+
+.upload-area:hover {
+    border-color: #B8860B;
+    background: linear-gradient(135deg, #F0E68C 0%, #DAA520 100%);
+    transform: translateY(-2px);
+}
+
+/* Button styling */
+.gradio-button {
+    background: linear-gradient(135deg, #FF4757 0%, #FFA502 100%) !important;
+    color: white !important;
+    font-weight: 600 !important;
+    border: 2px solid #B8860B !important;
+    border-radius: 8px !important;
+    padding: 12px 24px !important;
+    font-size:  1rem !important;
+    transition: all 0.3s ease !important;
+    box-shadow: 0 4px 15px rgba(255, 71, 87, 0.2) !important;
+}
+
+.gradio-button:hover {
+    background: linear-gradient(135deg, #FFA502 0%, #FF4757 100%) !important;
+    transform: translateY(-2px) !important;
+    box-shadow: 0 6px 20px rgba(255, 71, 87, 0.3) !important;
+}
+
+/* Input styling */
+.gradio-textbox, .gradio-dropdown {
+    border: 2px solid #DAA520 !important;
+    border-radius: 8px !important;
+    background: linear-gradient(135deg, #FFFACD 0%, #F5DEB3 100%) !important;
+}
+
+.gradio-textbox:focus, .gradio-dropdown:focus {
+    border-color: #B8860B !important;
+    box-shadow: 0 0 10px rgba(184, 134, 11, 0.3) !important;
+}
+"""
+
+# Create the Gradio interface
+with gr.Blocks(css=custom_css, title="AI-Powered Supply Chain Optimizer") as interface:
+    # Header
+    gr.HTML("""
+    <div class="main-header">
+        <h1>🚚 AI-Powered Supply Chain Optimizer</h1>
+        <p>Optimize your supply chain with real-time market intelligence and advanced analytics</p>
+    </div>
+    """)
+    
+    # Status message
+    gr.HTML(f"""
+    <div style="text-align: center; padding: 1rem; background: #E6FFE6; border-radius: 8px; margin-bottom: 1rem; border: 2px solid #90EE90;">
+        <strong>System Status:</strong> {startup_message}
+    </div>
+    """)
+    
+    with gr.Tabs():
+        # Tab 1: File Upload and Input
+        with gr.TabItem("📁 Data Input", elem_id="input-tab"):
+            gr.HTML('<div class="section-header">Upload Your Data Files</div>')
+            
+            with gr.Row():
+                with gr.Column():
+                    forecast_file = gr.File(
+                        label="📊 Forecast Data (Excel/CSV)",
+                        file_types=[".xlsx", ".xls", ".csv"],
+                        elem_classes=["upload-area"]
+                    )
+                    inventory_file = gr.File(
+                        label="📦 Inventory Data (Excel/CSV)",
+                        file_types=[".xlsx", ".xls", ".csv"],
+                        elem_classes=["upload-area"]
+                    )
+                with gr.Column():
+                    routes_file = gr.File(
+                        label="🗺️ Routes Data (Excel/CSV)",
+                        file_types=[".xlsx", ".xls", ".csv"],
+                        elem_classes=["upload-area"]
+                    )
+                    text_input = gr.Textbox(
+                        label="📝 Additional Context (Optional)",
+                        placeholder="Enter any additional business context, constraints, or special requirements...",
+                        lines=4,
+                        elem_classes=["upload-area"]
+                    )
+            
+            search_query = gr.Textbox(
+                label="🔍 Market Research Query",
+                placeholder="Enter search terms for real-time market analysis (e.g., 'tourism trends December 2024 hill stations')",
+                value="tourism trends December 2024 hill stations demand forecast",
+                lines=2
+            )
+            
+            optimize_btn = gr.Button(
+                "🚀 Optimize Supply Chain",
+                variant="primary",
+                size="lg",
+                elem_classes=["gradio-button"]
+            )
+            
+            processing_status = gr.Textbox(
+                label="📋 Processing Status",
+                interactive=False,
+                lines=3
+            )
+        
+        # Tab 2: Visualizations
+        with gr.TabItem("📈 Analytics Dashboard", elem_id="viz-tab"):
+            gr.HTML('<div class="section-header">Interactive Data Visualizations</div>')
+            
+            with gr.Row():
+                forecast_plot = gr.Plot(label="📊 Demand Forecast Analysis")
+                inventory_plot = gr.Plot(label="📦 Inventory vs Demand")
+            
+            route_plot = gr.Plot(label="🗺️ Route Network Analysis")
+        
+        # Tab 3: AI Analysis Results
+        with gr.TabItem("🤖 AI Analysis", elem_id="analysis-tab"):
+            gr.HTML('<div class="section-header">AI-Powered Market Analysis & Recommendations</div>')
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.HTML('<h3 style="color: #B8860B; text-align: center;">🔍 Market Intelligence & Forecast Analysis</h3>')
+                    analysis_output = gr.Textbox(
+                        label="",
+                        lines=15,
+                        interactive=False,
+                        elem_classes=["results-container"]
+                    )
+                
+                with gr.Column():
+                    gr.HTML('<h3 style="color: #B8860B; text-align: center;">⚡ Optimization Recommendations</h3>')
+                    optimization_output = gr.Textbox(
+                        label="",
+                        lines=15,
+                        interactive=False,
+                        elem_classes=["results-container"]
+                    )
+        
+        # Tab 4: Search Results
+        with gr.TabItem("🌐 Market Research", elem_id="search-tab"):
+            gr.HTML('<div class="section-header">Real-Time Market Intelligence</div>')
+            
+            search_output = gr.Textbox(
+                label="🔍 Market Research Results",
+                lines=20,
+                interactive=False,
+                elem_classes=["results-container"]
+            )
+    
+    # Footer
+    gr.HTML("""
+    <div class="footer">
+        <p><strong>AI-Powered Supply Chain Optimizer</strong> | Advanced Analytics & Real-Time Intelligence</p>
+        <p>🔧 Built with AutoGen, Tavily API, and Gradio | 🚀 Powered by OpenAI GPT</p>
+    </div>
+    """)
+    
+    # Connect the optimization function
+    optimize_btn.click(
+        fn=process_files_and_optimize,
+        inputs=[forecast_file, inventory_file, routes_file, text_input, search_query],
+        outputs=[
+            forecast_plot,
+            inventory_plot,
+            route_plot,
+            analysis_output,
+            optimization_output,
+            search_output,
+            processing_status
+        ],
+        show_progress=True
+    )
+
+# Launch the interface
+if __name__ == "__main__":
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True,
+        debug=True,
+        inbrowser=True
+    )