Update app.py

app.py

@@ -4,458 +4,296 @@ import datetime
 import pytz
 import asyncio
 import requests
-from typing import Dict, Any
 
 # Framework 1: LlamaIndex
-from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.core.agent import ReActAgent
 from llama_index.core.tools import FunctionTool
-from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+from llama_index.llms.huggingface import HuggingFaceInferenceAPI
 
 # Framework 2: smolagents
-from smolagents import CodeAgent, DuckDuckGoSearchTool, tool, InferenceClientModel
+from smolagents import CodeAgent, DuckDuckGoSearchTool, tool
 
 # 0. SHARED CONFIG
 HF_TOKEN = os.getenv("HF_TOKEN")
-WEATHER_API_KEY = os.getenv("WEATHER_API_KEY", "your-openweather-api-key")  # Get from: https://openweathermap.org/api
 MODEL_ID = "Qwen/Qwen2.5-7B-Instruct"
 
 # ==========================================
-# ENHANCED WEATHER FUNCTIONALITY
+# WEATHER FUNCTION WITH REAL API
 # ==========================================
-class WeatherService:
-    def __init__(self, api_key: str = None):
-        self.api_key = api_key or WEATHER_API_KEY
-        self.base_url = "http://api.openweathermap.org/data/2.5/weather"
-    
-    def get_weather(self, location: str) -> Dict[str, Any]:
-        """Get real weather data for a location"""
-        try:
-            params = {
-                'q': location,
-                'appid': self.api_key,
-                'units': 'metric',
-                'lang': 'en'
-            }
-            
-            response = requests.get(self.base_url, params=params, timeout=10)
-            response.raise_for_status()
+def get_weather(location: str) -> str:
+    """Get weather for a location using OpenWeatherMap API"""
+    try:
+        # You can get a free API key from https://openweathermap.org/api
+        api_key = os.getenv("WEATHER_API_KEY", "")
+        
+        if api_key:
+            url = f"http://api.openweathermap.org/data/2.5/weather?q={location}&appid={api_key}&units=metric"
+            response = requests.get(url, timeout=5)
             data = response.json()
             
-            return {
-                'temperature': data['main']['temp'],
-                'feels_like': data['main']['feels_like'],
-                'humidity': data['main']['humidity'],
-                'pressure': data['main']['pressure'],
-                'description': data['weather'][0]['description'].title(),
-                'wind_speed': data['wind']['speed'],
-                'wind_direction': self.get_wind_direction(data['wind'].get('deg', 0)),
-                'location': f"{data['name']}, {data['sys']['country']}",
-                'icon': data['weather'][0]['icon'],
-                'timestamp': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            if response.status_code == 200:
+                temp = data['main']['temp']
+                desc = data['weather'][0]['description']
+                humidity = data['main']['humidity']
+                return f"🌤️ Weather in {location}: {desc}, {temp}°C, Humidity: {humidity}%"
+            else:
+                # Fallback to mock data if API fails
+                return f"🌤️ Weather in {location}: Sunny, 22°C (mock data - add real API key for live weather)"
+        else:
+            # Mock weather if no API key
+            weather_data = {
+                "tokyo": "Cloudy, 18°C",
+                "london": "Rainy, 12°C",
+                "new york": "Sunny, 15°C",
+                "paris": "Partly Cloudy, 14°C",
+                "sydney": "Clear, 22°C"
             }
-        except Exception as e:
-            # Fallback to mock data if API fails
-            return self.get_mock_weather(location)
-    
-    def get_mock_weather(self, location: str) -> Dict[str, Any]:
-        """Fallback mock weather data"""
-        mock_temps = {
-            'tokyo': 18, 'london': 12, 'new york': 15, 
-            'paris': 14, 'sydney': 22, 'dubai': 28
-        }
-        temp = mock_temps.get(location.lower(), 20)
-        
-        return {
-            'temperature': temp,
-            'feels_like': temp + 2,
-            'humidity': 65,
-            'pressure': 1013,
-            'description': 'Partly Cloudy',
-            'wind_speed': 3.5,
-            'wind_direction': 'NW',
-            'location': location.title(),
-            'icon': '03d',
-            'timestamp': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
-            'note': 'Using mock data (add real API key for live weather)'
-        }
-    
-    def get_wind_direction(self, degrees: float) -> str:
-        """Convert wind degrees to cardinal direction"""
-        directions = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 
-                     'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW']
-        index = round(degrees / 22.5) % 16
-        return directions[index]
-    
-    def format_weather_report(self, weather_data: Dict[str, Any]) -> str:
-        """Format weather data into a readable report"""
-        emoji_map = {
-            'Clear': '☀️', 'Clouds': '☁️', 'Rain': '🌧️',
-            'Snow': '❄️', 'Thunderstorm': '⛈️', 'Drizzle': '🌦️',
-            'Mist': '🌫️', 'Smoke': '💨', 'Haze': '😶‍🌫️'
-        }
-        
-        description = weather_data['description']
-        emoji = emoji_map.get(description.split()[0], '🌈')
-        
-        report = f"""
-{emoji} **Weather Report for {weather_data['location']}** {emoji}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-**Temperature:** {weather_data['temperature']:.1f}°C
-**Feels Like:** {weather_data['feels_like']:.1f}°C
-**Conditions:** {description}
-**Humidity:** {weather_data['humidity']}%
-**Pressure:** {weather_data['pressure']} hPa
-**Wind:** {weather_data['wind_speed']} m/s {weather_data['wind_direction']}
-**Updated:** {weather_data['timestamp']}
-"""
-        if 'note' in weather_data:
-            report += f"\n⚠️ *{weather_data['note']}*"
-        
-        return report
-
-weather_service = WeatherService()
+            for city, weather in weather_data.items():
+                if city in location.lower():
+                    return f"🌤️ Weather in {location}: {weather} (mock data)"
+            return f"🌤️ Weather in {location}: Sunny, 22°C (mock data - set WEATHER_API_KEY for real data)"
+    except Exception as e:
+        return f"🌤️ Weather in {location}: Sunny, 22°C (error: {str(e)[:50]})"
 
 # ==========================================
-# ENHANCED TIME FUNCTIONS
+# TIME FUNCTIONS
 # ==========================================
 def get_tokyo_time() -> str:
     """Returns the current time in Tokyo, Japan."""
     tz = pytz.timezone('Asia/Tokyo')
-    current_time = datetime.datetime.now(tz)
-    return f"**Tokyo Time:** {current_time.strftime('%A, %B %d, %Y %H:%M:%S')} (JST)"
+    now = datetime.datetime.now(tz)
+    return f"🕐 Tokyo Time: {now.strftime('%A, %B %d, %Y %H:%M:%S')}"
 
-def get_world_time(city: str = None) -> str:
-    """Get current time for various cities"""
+def get_world_time(city: str = "all") -> str:
+    """Get current time for various cities."""
     timezones = {
-        'tokyo': 'Asia/Tokyo',
-        'new york': 'America/New_York',
-        'london': 'Europe/London',
-        'paris': 'Europe/Paris',
-        'sydney': 'Australia/Sydney',
-        'dubai': 'Asia/Dubai',
-        'singapore': 'Asia/Singapore',
-        'mumbai': 'Asia/Kolkata'
+        "Tokyo": "Asia/Tokyo",
+        "New York": "America/New_York",
+        "London": "Europe/London",
+        "Paris": "Europe/Paris",
+        "Sydney": "Australia/Sydney",
+        "Dubai": "Asia/Dubai",
+        "Singapore": "Asia/Singapore"
     }
     
-    if not city:
-        # Return all times
-        result = "🌍 **World Clock** 🌍\n━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
-        for city_name, tz_str in timezones.items():
-            tz = pytz.timezone(tz_str)
-            current_time = datetime.datetime.now(tz)
-            result += f"• **{city_name.title()}:** {current_time.strftime('%H:%M:%S')}\n"
-        return result
+    if city.lower() != "all" and city.title() in timezones:
+        tz = pytz.timezone(timezones[city.title()])
+        now = datetime.datetime.now(tz)
+        return f"🕐 {city} Time: {now.strftime('%H:%M:%S')}"
     
-    city_lower = city.lower()
-    if city_lower in timezones:
-        tz = pytz.timezone(timezones[city_lower])
-        current_time = datetime.datetime.now(tz)
-        return f"**{city.title()} Time:** {current_time.strftime('%A, %B %d, %Y %H:%M:%S')}"
-    else:
-        return f"Sorry, I don't have timezone data for {city}. Available cities: {', '.join(timezones.keys())}"
+    result = "🌍 World Clock:\n"
+    for city_name, tz_str in timezones.items():
+        tz = pytz.timezone(tz_str)
+        now = datetime.datetime.now(tz)
+        result += f"• {city_name}: {now.strftime('%H:%M:%S')}\n"
+    return result
 
 # ==========================================
-# PART 1: LLAMAINDEX AGENT (ENHANCED)
+# CALCULATOR FUNCTION
 # ==========================================
-li_llm = HuggingFaceInferenceAPI(
-    model_name=MODEL_ID,
-    token=HF_TOKEN,
-    provider="together"
-)
-
-@tool
-def enhanced_weather_tool(location: str) -> str:
-    """Get detailed weather information for any location worldwide.
-    Args:
-        location: City name (e.g., 'Tokyo', 'New York', 'London')
-    """
-    weather_data = weather_service.get_weather(location)
-    return weather_service.format_weather_report(weather_data)
-
-@tool
-def world_time_tool(city: str = None) -> str:
-    """Get current time for world cities.
-    Args:
-        city: Optional city name. If not provided, shows all major cities.
-    """
-    return get_world_time(city)
-
-@tool
-def calculator_tool(expression: str) -> str:
-    """Evaluate mathematical expressions.
-    Args:
-        expression: Mathematical expression to calculate (e.g., '2 + 2', 'sqrt(16)')
-    """
+def calculate(expression: str) -> str:
+    """Calculate mathematical expressions."""
     try:
-        # Safe evaluation
+        # Safe evaluation with basic math functions
         import math
-        allowed_names = {k: v for k, v in math.__dict__.items() if not k.startswith("_")}
-        allowed_names.update({'abs': abs, 'round': round})
-        
-        # Compile the expression
-        code = compile(expression, "<string>", "eval")
-        
-        # Check for disallowed names
-        for name in code.co_names:
-            if name not in allowed_names:
-                raise NameError(f"Use of {name} is not allowed")
         
-        result = eval(code, {"__builtins__": {}}, allowed_names)
-        return f"**Result:** {expression} = {result}"
-    except Exception as e:
-        return f"Calculation Error: {str(e)}. Please use valid mathematical expressions."
-
-# Create LlamaIndex tools
-li_tools = [
-    FunctionTool.from_defaults(fn=get_tokyo_time),
-    FunctionTool.from_defaults(fn=lambda location: enhanced_weather_tool(location)),
-    FunctionTool.from_defaults(fn=lambda city=None: world_time_tool(city)),
-    FunctionTool.from_defaults(fn=lambda expr: calculator_tool(expr))
-]
-
-li_agent = AgentWorkflow.from_tools_or_functions(
-    li_tools,
-    llm=li_llm,
-)
-
-async def chat_llama(message, history):
-    try:
-        # Add some thinking emoji
-        thinking_msg = "🤔 Thinking..."
-        
-        # Process the message
-        result = await li_agent.run(user_msg=message)
+        # Create a safe environment
+        safe_dict = {
+            'abs': abs, 'round': round, 'min': min, 'max': max,
+            'sum': sum, 'len': len, 'int': int, 'float': float,
+            'math': math, 'sqrt': math.sqrt, 'pow': math.pow,
+            'sin': math.sin, 'cos': math.cos, 'tan': math.tan,
+            'pi': math.pi, 'e': math.e
+        }
         
-        # Format response
-        response = str(result)
-        if "weather" in message.lower() and "tokyo" not in message.lower():
-            # Extract location from message
-            words = message.lower().split()
-            for word in words:
-                if word in ['weather', 'forecast', 'temperature']:
-                    continue
-                # Try to find a location
-                weather_data = weather_service.get_weather(word)
-                if 'mock' not in str(weather_data.get('note', '')):
-                    response = weather_service.format_weather_report(weather_data)
-                    break
+        # Remove any dangerous characters
+        expression = ''.join(c for c in expression if c.isalnum() or c in ' +-*/().,')
         
-        return response
+        result = eval(expression, {"__builtins__": {}}, safe_dict)
+        return f"🧮 {expression} = {result}"
     except Exception as e:
-        return f"❌ LlamaIndex Error: {str(e)}"
+        return f"❌ Calculation error: {str(e)[:100]}"
 
 # ==========================================
-# PART 2: SMOLAGENTS (ENHANCED)
+# PART 1: LLAMAINDEX AGENT (FIXED)
 # ==========================================
-smol_model = InferenceClientModel(
-    model_id=MODEL_ID,
-    token=HF_TOKEN,
-    provider="together"
-)
-
-smol_agent = CodeAgent(
-    model=smol_model,
-    tools=[enhanced_weather_tool, world_time_tool, calculator_tool, DuckDuckGoSearchTool()]
-)
-
-def chat_smol(message, history):
-    try:
-        response = smol_agent.run(message)
-        return str(response)
-    except Exception as e:
-        return f"❌ Smolagents Error: {str(e)}"
+try:
+    li_llm = HuggingFaceInferenceAPI(
+        model_name=MODEL_ID,
+        token=HF_TOKEN,
+    )
+    
+    # Create tools for LlamaIndex
+    li_tools = [
+        FunctionTool.from_defaults(fn=get_tokyo_time, name="get_tokyo_time"),
+        FunctionTool.from_defaults(fn=get_weather, name="get_weather"),
+        FunctionTool.from_defaults(fn=get_world_time, name="get_world_time"),
+        FunctionTool.from_defaults(fn=calculate, name="calculate")
+    ]
+    
+    li_agent = ReActAgent.from_tools(
+        li_tools,
+        llm=li_llm,
+        verbose=False
+    )
+    
+    async def chat_llama(message, history):
+        try:
+            response = await li_agent.achat(message)
+            return str(response)
+        except Exception as e:
+            return f"❌ LlamaIndex Error: {str(e)[:200]}"
+            
+except Exception as e:
+    print(f"LlamaIndex setup error: {e}")
+    async def chat_llama(message, history):
+        return f"❌ LlamaIndex not available: {str(e)[:200]}"
 
 # ==========================================
-# PART 3: ENHANCED GRADIO UI
+# PART 2: SMOLAGENTS
 # ==========================================
-def create_weather_component():
-    """Create a standalone weather component"""
-    with gr.Column(variant="panel"):
-        gr.Markdown("## 🌤️ Quick Weather Check")
-        
-        with gr.Row():
-            location_input = gr.Textbox(
-                label="City Name",
-                placeholder="Enter city name...",
-                scale=4
-            )
-            get_weather_btn = gr.Button("Get Weather", variant="primary", scale=1)
-        
-        weather_output = gr.Markdown(label="Weather Report")
-        
-        # Example locations
-        examples = gr.Examples(
-            examples=["Tokyo", "London", "New York", "Paris", "Sydney"],
-            inputs=location_input,
-            label="Try these cities:"
-        )
-        
-        def get_weather(location):
-            if not location:
-                return "Please enter a city name."
-            weather_data = weather_service.get_weather(location)
-            return weather_service.format_weather_report(weather_data)
-        
-        get_weather_btn.click(
-            get_weather,
-            inputs=location_input,
-            outputs=weather_output
-        )
-        
-        return location_input, weather_output
-
-def create_world_clock_component():
-    """Create a world clock component"""
-    with gr.Column(variant="panel"):
-        gr.Markdown("## 🌍 World Clock")
-        
-        with gr.Row():
-            refresh_btn = gr.Button("🔄 Refresh Times", variant="secondary")
-            all_cities_btn = gr.Button("Show All Cities", variant="primary")
-        
-        time_output = gr.Markdown()
-        
-        # Initial display
-        time_output.value = get_world_time()
-        
-        def refresh_times():
-            return get_world_time()
-        
-        refresh_btn.click(refresh_times, outputs=time_output)
-        all_cities_btn.click(refresh_times, outputs=time_output)
-        
-        return time_output
-
-def create_calculator_component():
-    """Create a simple calculator component"""
-    with gr.Column(variant="panel"):
-        gr.Markdown("## 🧮 Quick Calculator")
-        
-        with gr.Row():
-            calc_input = gr.Textbox(
-                label="Math Expression",
-                placeholder="e.g., 2 + 2, 3 * (4 + 5), sqrt(16)...",
-                scale=4
-            )
-            calc_btn = gr.Button("Calculate", variant="primary", scale=1)
-        
-        calc_output = gr.Markdown(label="Result")
-        
-        examples = gr.Examples(
-            examples=["2 + 2", "3 * (4 + 5)", "sqrt(16)", "sin(30)", "2 ** 8"],
-            inputs=calc_input,
-            label="Try these:"
-        )
-        
-        def calculate(expression):
-            return calculator_tool(expression)
-        
-        calc_btn.click(
-            calculate,
-            inputs=calc_input,
-            outputs=calc_output
-        )
-        
-        return calc_input, calc_output
+try:
+    from smolagents import CodeAgent, DuckDuckGoSearchTool, tool
+    
+    @tool
+    def weather_tool(location: str) -> str:
+        """Get the current weather for a location."""
+        return get_weather(location)
+    
+    @tool
+    def time_tool(city: str = "all") -> str:
+        """Get current time for a city or all major cities."""
+        return get_world_time(city)
+    
+    @tool
+    def calculator_tool(expression: str) -> str:
+        """Calculate mathematical expressions."""
+        return calculate(expression)
+    
+    smol_agent = CodeAgent(
+        tools=[weather_tool, time_tool, calculator_tool, DuckDuckGoSearchTool()],
+        model=MODEL_ID,
+        max_steps=5
+    )
+    
+    def chat_smol(message, history):
+        try:
+            response = smol_agent.run(message)
+            return str(response)
+        except Exception as e:
+            return f"❌ Smolagents Error: {str(e)[:200]}"
+            
+except Exception as e:
+    print(f"Smolagents setup error: {e}")
+    def chat_smol(message, history):
+        return f"❌ Smolagents not available: {str(e)[:200]}"
 
+# ==========================================
+# PART 3: UNIFIED GRADIO UI
+# ==========================================
 with gr.Blocks(theme=gr.themes.Soft(), title="🤖 AI Agent Studio") as demo:
     # Header
-    with gr.Row():
-        gr.Markdown("# 🚀 AI Agent Studio")
-    
-    with gr.Row():
-        gr.Markdown(f"### Powered by **{MODEL_ID}** via Together AI")
-    
-    # API Key Notice
-    if "your-openweather-api-key" in WEATHER_API_KEY:
-        gr.Markdown("""
-        ⚠️ **Note:** Using mock weather data. For real weather, get a free API key from 
-        [OpenWeatherMap](https://openweathermap.org/api) and set it as `WEATHER_API_KEY` environment variable.
-        """)
+    gr.Markdown("# 🤖 AI Agent Studio")
+    gr.Markdown(f"**Model:** {MODEL_ID} | **Provider:** Together AI")
     
-    # Sidebar with utility tools
+    # Quick Tools Section
     with gr.Row():
-        # Left sidebar - Utility tools
-        with gr.Column(scale=1, variant="panel"):
-            create_weather_component()
-            create_world_clock_component()
-            create_calculator_component()
+        with gr.Column(scale=1):
+            gr.Markdown("### 🛠️ Quick Tools")
             
-            # Agent Capabilities Info
-            with gr.Column(variant="panel"):
-                gr.Markdown("## 🤖 Agent Capabilities")
-                gr.Markdown("""
-                **Both Agents Can:**
-                • 📅 Get current time worldwide
-                • 🌤️ Check weather forecasts
-                • 🧮 Perform calculations
-                • 🔍 Search the web (smolagents)
-                • 💬 Natural conversation
+            # Weather Tool
+            with gr.Group():
+                weather_city = gr.Textbox(
+                    label="Check Weather",
+                    placeholder="Enter city name...",
+                    scale=4
+                )
+                weather_btn = gr.Button("🌤️ Get Weather", scale=1)
+                weather_output = gr.Textbox(label="Result", interactive=False)
                 
-                **Try asking:**
-                - "What's the weather in London?"
-                - "What time is it in Tokyo?"
-                - "Calculate 15% of 200"
-                - "Tell me about AI news"
-                """)
-        
-        # Main content area - Chat interfaces
-        with gr.Column(scale=3):
-            with gr.Tab("🦙 LlamaIndex Agent", id="llama"):
+                def get_weather_quick(city):
+                    return get_weather(city) if city else "Please enter a city name."
+                
+                weather_btn.click(
+                    get_weather_quick,
+                    inputs=weather_city,
+                    outputs=weather_output
+                )
+            
+            # Calculator Tool
+            with gr.Group():
+                calc_expr = gr.Textbox(
+                    label="Calculator",
+                    placeholder="Enter math expression...",
+                    scale=4
+                )
+                calc_btn = gr.Button("🧮 Calculate", scale=1)
+                calc_output = gr.Textbox(label="Result", interactive=False)
+                
+                calc_btn.click(
+                    calculate,
+                    inputs=calc_expr,
+                    outputs=calc_output
+                )
+            
+            # Time Tool
+            with gr.Group():
+                time_btn = gr.Button("🌍 Show World Clock")
+                time_output = gr.Textbox(label="World Times", interactive=False)
+                
+                time_btn.click(
+                    lambda: get_world_time("all"),
+                    outputs=time_output
+                )
+    
+    # Chat Agents Section
+    with gr.Row():
+        with gr.Tabs():
+            with gr.TabItem("🦙 LlamaIndex Agent"):
                 llama_chat = gr.ChatInterface(
                     fn=chat_llama,
-                    chatbot=gr.Chatbot(height=500, label="LlamaIndex Agent"),
-                    textbox=gr.Textbox(
-                        placeholder="Ask about weather, time, calculations...",
-                        container=False,
-                        scale=7
-                    ),
-                    title="LlamaIndex Workflow Agent",
-                    description="Uses structured workflows with function tools",
-                    theme="soft",
+                    title="LlamaIndex ReAct Agent",
+                    description="Structured agent with reasoning capabilities",
                     examples=[
                         "What's the weather in Tokyo?",
-                        "What time is it in New York and Paris?",
+                        "What time is it in New York?",
                         "Calculate 25 * 4 + 18",
-                        "Tell me about today's weather worldwide"
+                        "Tell me the time in London and Sydney"
                     ]
                 )
             
-            with gr.Tab("🔬 Smolagents CodeAgent", id="smol"):
+            with gr.TabItem("🔬 Smolagents"):
                 smol_chat = gr.ChatInterface(
                     fn=chat_smol,
-                    chatbot=gr.Chatbot(height=500, label="Smolagents CodeAgent"),
-                    textbox=gr.Textbox(
-                        placeholder="Ask anything or request web search...",
-                        container=False,
-                        scale=7
-                    ),
-                    title="Smolagents Code Agent",
-                    description="Uses code execution with search capabilities",
-                    theme="soft",
+                    title="Smolagents CodeAgent",
+                    description="Code-based agent with web search",
                     examples=[
-                        "Search for latest AI developments",
-                        "What's the weather forecast for this week?",
-                        "Explain quantum computing",
-                        "Calculate the area of a circle with radius 5"
+                        "Search for AI news",
+                        "What's the weather like today?",
+                        "Calculate 15% of 200",
+                        "Tell me about machine learning"
                     ]
                 )
     
     # Footer
-    with gr.Row():
+    gr.Markdown("---")
+    gr.Markdown("""
+    ### 💡 Try asking:
+    - "What's the weather in London and what time is it there?"
+    - "Calculate the area of a circle with radius 5"
+    - "Search for latest technology news"
+    - "Compare time between Tokyo and New York"
+    """)
+    
+    # API Key Notice
+    if not os.getenv("WEATHER_API_KEY"):
         gr.Markdown("""
-        ---
-        **Tips:**
-        1. LlamaIndex is better for structured workflows
-        2. Smolagents can search the web in real-time
-        3. Use the sidebar for quick weather/time checks
-        4. Both agents support natural language queries
+        ⚠️ **Note:** Using mock weather data. For real weather, add `WEATHER_API_KEY` to your Hugging Face Space secrets.
         """)
 
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        debug=True
+        share=True
     )