Update app.py

app.py

@@ -4,115 +4,99 @@ import requests
 import boto3
 import streamlit as st
 from dotenv import load_dotenv
- 
+
+# Load env (for local dev / Hugging Face secrets)
 load_dotenv()
- 
-# Environment config
+
+# Configs
 OPENWEATHERMAP_API_KEY = os.getenv("OPENWEATHERMAP_API_KEY")
 AWS_REGION = os.getenv("AWS_REGION", "us-east-1")
- 
-# Bedrock Claude client
-bedrock_runtime = boto3.client(
-        service_name='bedrock-runtime',
-        region_name=os.getenv('AWS_REGION'),
-        aws_access_key_id=os.getenv('AWS_ACCESS_KEY_ID'),
-        aws_secret_access_key=os.getenv('AWS_SECRET_ACCESS_KEY')
-    )
- 
-# App UI
-st.title("Weather Assistant - Umbrella Advisor")
-st.markdown("Ask me if you should carry an umbrella tomorrow!")
- 
-# Session state for chat
+
+# AWS Bedrock Runtime
+session = boto3.Session(
+    aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+    aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+    region_name=AWS_REGION
+)
+bedrock_runtime = session.client("bedrock-runtime")
+
+# Streamlit Page Config
+st.set_page_config(page_title="🌤️ Weather Umbrella Advisor", page_icon="☔", layout="centered")
+
+# --- Title Section ---
+st.markdown("""
+<div style="text-align: center;">
+    <h1 style="color: #3c79f5;">☔ Weather Umbrella Advisor</h1>
+    <p style="font-size: 18px;">Ask me if you need to carry an umbrella tomorrow, powered by <b>Claude + OpenWeatherMap</b>.</p>
+</div>
+""", unsafe_allow_html=True)
+
+# Chat history state
 if "messages" not in st.session_state:
     st.session_state.messages = []
- 
-# Chat history display
+
+# --- Display Past Messages ---
 for msg in st.session_state.messages:
     with st.chat_message(msg["role"]):
         st.markdown(msg["content"])
- 
- 
+
+# --- Weather API Call ---
 def get_weather(location):
-    """Get weather forecast for a specific location"""
-    print(f"Getting weather for: {location}")
-   
-    # Validate location input
-    if not location or location.strip() == "":
-        return {"error": "Please specify a valid location/city name."}
-   
-    location = location.strip()
-    geo_url = f"http://api.openweathermap.org/geo/1.0/direct?q={location}&limit=1&appid={OPENWEATHERMAP_API_KEY}"
-   
+    """Fetches weather data for next 24 hours for given city."""
+    if not location.strip():
+        return {"error": "Please specify a valid location."}
+    
     try:
+        geo_url = f"http://api.openweathermap.org/geo/1.0/direct?q={location}&limit=1&appid={OPENWEATHERMAP_API_KEY}"
         geo_resp = requests.get(geo_url).json()
-       
-        if not geo_resp or len(geo_resp) == 0:
-            return {"error": f"Location '{location}' not found. Please check the spelling and try again."}
-       
+        if not geo_resp:
+            return {"error": f"Location '{location}' not found."}
+        
         lat, lon = geo_resp[0]['lat'], geo_resp[0]['lon']
-    except (KeyError, IndexError, requests.RequestException) as e:
-        return {"error": f"Error getting location data for '{location}': {str(e)}"}
-    try:
         weather_url = f"http://api.openweathermap.org/data/2.5/forecast?lat={lat}&lon={lon}&appid={OPENWEATHERMAP_API_KEY}&units=metric"
         weather_data = requests.get(weather_url).json()
-       
         if 'list' not in weather_data:
-            return {"error": f"Unable to get weather forecast for '{location}'."}
-       
-        forecast = []
-        for f in weather_data['list'][:8]:  # Next 24 hours
-            forecast.append({
-                "time": f["dt_txt"],
-                "description": f["weather"][0]["description"],
-                "rain_probability": f.get("pop", 0) * 100,
-                "temp": f["main"]["temp"],
-                "humidity": f["main"]["humidity"]
-            })
-       
-        return {
-            "location": location,
-            "forecast": forecast
-        }
-    except (KeyError, requests.RequestException) as e:
-        return {"error": f"Error getting weather forecast for '{location}': {str(e)}"}
- 
- 
+            return {"error": f"Unable to fetch weather forecast for '{location}'."}
+
+        forecast = [{
+            "time": f["dt_txt"],
+            "description": f["weather"][0]["description"].capitalize(),
+            "rain_probability": round(f.get("pop", 0) * 100, 1),
+            "temp": f["main"]["temp"],
+            "humidity": f["main"]["humidity"]
+        } for f in weather_data['list'][:8]]  # 24 hrs = 8 x 3hr blocks
+
+        return {"location": location.title(), "forecast": forecast}
+    
+    except Exception as e:
+        return {"error": str(e)}
+
+# --- ReAct-Powered Response Generator ---
 def generate_react_response(user_input, conversation_history=""):
-    """Generate response using ReAct (Reasoning + Acting) approach"""
-   
-    system_prompt = """You are a helpful weather assistant that uses ReAct (Reasoning + Acting) methodology to help users decide about carrying umbrellas.
- 
-Follow this process:
-1. **Think**: Analyze what the user is asking
-2. **Act**: Use available tools if needed
-3. **Observe**: Process the results
-4. **Reason**: Draw conclusions and provide advice
- 
-Available tools:
-- get_weather(location): Gets weather forecast for tomorrow
- 
-When you need to get weather data, respond with this JSON format:
+    """Uses Claude with ReAct to give umbrella recommendation."""
+    system_prompt = """You are a helpful assistant using the ReAct (Reasoning + Acting) method to answer whether the user should carry an umbrella tomorrow.
+
+Steps:
+1. Think about the question.
+2. Act using get_weather(location).
+3. Observe the weather data.
+4. Reason and give a clear answer.
+
+When you need weather data, reply in this format:
 {
-  "thought": "I need to get weather data for [location] to advise about umbrella",
+  "thought": "Need weather info for [location]",
   "action": "get_weather",
   "action_input": {"location": "city_name"}
 }
- 
-When you have all needed information, provide a conversational response that includes:
-- The location
-- Your reasoning based on weather conditions
-- Clear umbrella advice
- 
-Example: "You do not need to carry an umbrella tomorrow as the weather in New York will be sunny with no chance of rain."
- 
-If the user doesn't specify a location, ask them to specify it conversationally."""
- 
-    # Build conversation context
-    messages = [
-        {"role": "user", "content": f"{system_prompt}\n\nConversation history: {conversation_history}\n\nUser: {user_input}"}
-    ]
-   
+
+If no location is mentioned, ask the user to specify one.
+
+If you have the weather data, give a natural reply like:
+"You do not need an umbrella tomorrow in London, as it's expected to be sunny and dry."
+"""
+
+    messages = [{"role": "user", "content": f"{system_prompt}\n\nChat history:\n{conversation_history}\n\nUser: {user_input}"}]
+
     claude_body = {
         "anthropic_version": "bedrock-2023-05-31",
         "max_tokens": 1000,
@@ -120,120 +104,93 @@ If the user doesn't specify a location, ask them to specify it conversationally.
         "top_p": 0.9,
         "messages": messages
     }
- 
-    response = bedrock.invoke_model(
+
+    response = bedrock_runtime.invoke_model(
         modelId="anthropic.claude-3-sonnet-20240229-v1:0",
         contentType="application/json",
         accept="application/json",
         body=json.dumps(claude_body),
     )
- 
     content = json.loads(response["body"].read())["content"][0]["text"].strip()
- 
-    # Try to parse as ReAct JSON
+
+    # Try parsing ReAct JSON
     try:
-        react_response = json.loads(content)
-       
-        if react_response.get("action") == "get_weather":
-            location = react_response.get("action_input", {}).get("location", "").strip()
-            thought = react_response.get("thought", "")
-           
-            # Validate location before calling weather function
+        parsed = json.loads(content)
+        if parsed.get("action") == "get_weather":
+            location = parsed["action_input"]["location"]
             if not location:
-                return "I need to know which city or location you're asking about. Could you please specify the location?"
-           
-            # Get weather data
+                return "Please tell me which city you're asking about 🌍."
+
             weather_data = get_weather(location)
-           
             if "error" in weather_data:
                 return weather_data["error"]
-           
-            # Process weather data and generate final reasoning
-            try:
-                reasoning_prompt = f"""Based on this weather data for {location}, provide your final umbrella recommendation:
- 
-Weather forecast: {json.dumps(weather_data, indent=2)}
- 
-Your previous thought: {thought}
- 
-Provide a conversational response that includes:
-1. The location
-2. Your reasoning based on the weather conditions
-3. Clear umbrella advice
- 
-Format like: "You [do/do not] need to carry an umbrella tomorrow as the weather in [location] will be [conditions and reasoning]."
+
+            forecast_str = json.dumps(weather_data, indent=2)
+            reasoning_prompt = f"""Based on this weather forecast for {location}, give an umbrella recommendation:
+
+{forecast_str}
+
+Return a natural response that includes:
+- Location
+- Conditions (rain %, sky, etc.)
+- Clear YES/NO umbrella advice
 """
-               
-                final_messages = [{"role": "user", "content": reasoning_prompt}]
-               
-                final_body = {
+            final_response = bedrock_runtime.invoke_model(
+                modelId="anthropic.claude-3-sonnet-20240229-v1:0",
+                contentType="application/json",
+                accept="application/json",
+                body=json.dumps({
                     "anthropic_version": "bedrock-2023-05-31",
                     "max_tokens": 500,
                     "temperature": 0.7,
-                    "messages": final_messages
-                }
-               
-                final_response = bedrock.invoke_model(
-                    modelId="anthropic.claude-3-sonnet-20240229-v1:0",
-                    contentType="application/json",
-                    accept="application/json",
-                    body=json.dumps(final_body),
-                )
-               
-                final_content = json.loads(final_response["body"].read())["content"][0]["text"].strip()
-                return final_content
-            except Exception as e:
-                return f"Error processing weather data: {str(e)}"
-           
+                    "messages": [{"role": "user", "content": reasoning_prompt}]
+                })
+            )
+            return json.loads(final_response["body"].read())["content"][0]["text"].strip()
+
     except json.JSONDecodeError:
-        # If not JSON, return the content as is (probably asking for location)
-        pass
-   
+        pass  # Possibly just a reply from Claude
+
     return content
- 
- 
-def build_conversation_history():
-    """Build conversation history for context"""
-    history = []
-    for msg in st.session_state.messages[-4:]:  # Last 4 messages for context
-        history.append(f"{msg['role'].capitalize()}: {msg['content']}")
-    return "\n".join(history)
- 
- 
-if prompt := st.chat_input("Type your question here..."):
-    st.session_state.messages.append({"role": "user", "content": prompt})
+
+# --- Chat Input Handling ---
+def build_convo_history():
+    return "\n".join([f"{m['role'].capitalize()}: {m['content']}" for m in st.session_state.messages[-4:]])
+
+if user_prompt := st.chat_input("Ask: Do I need an umbrella tomorrow?"):
+    st.session_state.messages.append({"role": "user", "content": user_prompt})
     with st.chat_message("user"):
-        st.markdown(prompt)
- 
+        st.markdown(user_prompt)
+
     with st.chat_message("assistant"):
-        with st.spinner("Thinking..."):
-            conversation_history = build_conversation_history()
-            reply = generate_react_response(prompt, conversation_history)
-            st.markdown(reply)
-    st.session_state.messages.append({"role": "assistant", "content": reply})
- 
- 
+        with st.spinner("Thinking... 🤔"):
+            history = build_convo_history()
+            response = generate_react_response(user_prompt, history)
+            st.markdown(response)
+
+    st.session_state.messages.append({"role": "assistant", "content": response})
+
+# --- Sidebar ---
 with st.sidebar:
-    st.header("About")
-    st.markdown("""
-    - Powered by **AWS Bedrock (Claude Sonnet)**  
-    - Uses **ReAct (Reasoning + Acting)** methodology
-    - Retrieves real-time data from **OpenWeatherMap**  
-    - Provides step-by-step reasoning for umbrella advice
-    """)
-   
-    st.subheader("Sample Prompts")
-    st.markdown("""
-    - Should I bring an umbrella tomorrow?  
-    - Will it rain in Delhi tomorrow?  
-    - Do I need an umbrella in Tokyo?
-    - Should I carry an umbrella tomorrow in London?
-    """)
-   
-    st.subheader("ReAct Process")
+    st.image("https://img.icons8.com/clouds/100/umbrella.png", width=100)
+    st.markdown("## ☀️ About")
     st.markdown("""
-    1. **Think**: Analyze your question
-    2. **Act**: Get weather data if needed
-    3. **Observe**: Process weather information  
-    4. **Reason**: Provide umbrella advice with explanation
-    """)
+**Weather Assistant** gives you umbrella advice using:
+- 🌦️ Real-time weather via **OpenWeatherMap**
+- 🧠 Smart reasoning via **Claude (Bedrock)**
+- 🤖 ReAct method: Think • Act • Observe • Reason
+
+---
+
+### 💬 Try Saying
+- "Should I bring an umbrella tomorrow?"
+- "Will it rain in Delhi tomorrow?"
+- "Do I need an umbrella in Tokyo?"
+
+---
+
+### 🔧 Tools Used
+- Claude 3 Sonnet (Bedrock)
+- OpenWeatherMap API
+- Streamlit (frontend)
+""")