Update app.py

app.py

@@ -3,6 +3,8 @@ import gradio as gr
 import datetime
 import pytz
 import asyncio
+import requests
+from typing import Dict, Any
 
 # Framework 1: LlamaIndex
 from llama_index.core.agent.workflow import AgentWorkflow
@@ -14,24 +16,202 @@ from smolagents import CodeAgent, DuckDuckGoSearchTool, tool, InferenceClientMod
 
 # 0. SHARED CONFIG
 HF_TOKEN = os.getenv("HF_TOKEN")
-# 7B is the sweet spot for free serverless inference in 2026
+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"
 
 # ==========================================
-# PART 1: LLAMAINDEX AGENT
+# ENHANCED WEATHER FUNCTIONALITY
+# ==========================================
+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()
+            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')
+            }
+        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()
+
+# ==========================================
+# ENHANCED 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)"
+
+def get_world_time(city: str = None) -> 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'
+    }
+    
+    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
+    
+    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())}"
+
+# ==========================================
+# PART 1: LLAMAINDEX AGENT (ENHANCED)
 # ==========================================
 li_llm = HuggingFaceInferenceAPI(
     model_name=MODEL_ID,
     token=HF_TOKEN,
-    provider="together" 
+    provider="together"
 )
 
-def get_tokyo_time() -> str:
-    """Returns the current time in Tokyo, Japan."""
-    tz = pytz.timezone('Asia/Tokyo')
-    return f"The current time in Tokyo is {datetime.datetime.now(tz).strftime('%H:%M:%S')}"
+@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)')
+    """
+    try:
+        # Safe evaluation
+        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."
 
-li_tools = [FunctionTool.from_defaults(fn=get_tokyo_time)]
+# 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,
@@ -40,13 +220,32 @@ li_agent = AgentWorkflow.from_tools_or_functions(
 
 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)
-        return str(result)
+        
+        # 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
+        
+        return response
     except Exception as e:
-        return f"LlamaIndex Error: {str(e)}"
+        return f"❌ LlamaIndex Error: {str(e)}"
 
 # ==========================================
-# PART 2: SMOLAGENTS
+# PART 2: SMOLAGENTS (ENHANCED)
 # ==========================================
 smol_model = InferenceClientModel(
     model_id=MODEL_ID,
@@ -54,17 +253,9 @@ smol_model = InferenceClientModel(
     provider="together"
 )
 
-@tool
-def weather_tool(location: str) -> str:
-    """Get the current weather for a location.
-    Args:
-        location: The city name.
-    """
-    return f"The weather in {location} is currently sunny and 22°C."
-
 smol_agent = CodeAgent(
     model=smol_model,
-    tools=[weather_tool, DuckDuckGoSearchTool()]
+    tools=[enhanced_weather_tool, world_time_tool, calculator_tool, DuckDuckGoSearchTool()]
 )
 
 def chat_smol(message, history):
@@ -72,20 +263,199 @@ def chat_smol(message, history):
         response = smol_agent.run(message)
         return str(response)
     except Exception as e:
-        return f"Smolagents Error: {str(e)}"
+        return f"❌ Smolagents Error: {str(e)}"
 
 # ==========================================
-# PART 3: UNIFIED GRADIO UI
+# PART 3: ENHANCED GRADIO UI
 # ==========================================
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🤖 Consolidated AI Agent Space")
-    gr.Markdown(f"Currently using **{MODEL_ID}** via Together AI Provider.")
+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
+
+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")
     
-    with gr.Tab("LlamaIndex (Workflow)"):
-        gr.ChatInterface(fn=chat_llama)
+    # 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.
+        """)
+    
+    # Sidebar with utility tools
+    with gr.Row():
+        # Left sidebar - Utility tools
+        with gr.Column(scale=1, variant="panel"):
+            create_weather_component()
+            create_world_clock_component()
+            create_calculator_component()
+            
+            # 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
+                
+                **Try asking:**
+                - "What's the weather in London?"
+                - "What time is it in Tokyo?"
+                - "Calculate 15% of 200"
+                - "Tell me about AI news"
+                """)
         
-    with gr.Tab("smolagents (CodeAgent)"):
-        gr.ChatInterface(fn=chat_smol)
+        # Main content area - Chat interfaces
+        with gr.Column(scale=3):
+            with gr.Tab("🦙 LlamaIndex Agent", id="llama"):
+                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",
+                    examples=[
+                        "What's the weather in Tokyo?",
+                        "What time is it in New York and Paris?",
+                        "Calculate 25 * 4 + 18",
+                        "Tell me about today's weather worldwide"
+                    ]
+                )
+            
+            with gr.Tab("🔬 Smolagents CodeAgent", id="smol"):
+                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",
+                    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"
+                    ]
+                )
+    
+    # Footer
+    with gr.Row():
+        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
+        """)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True
+    )