initial commit

README.md

@@ -3,8 +3,8 @@ title: Assignment1KG
 emoji: 💬
 colorFrom: yellow
 colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
+sdk: streamlit
+sdk_version: 1.35.0
 app_file: app.py
 pinned: false
 license: apache-2.0

app.py

@@ -1,64 +1,234 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
+import os
+import json
+import requests
+import boto3
+import streamlit as st
+from dotenv import load_dotenv
+ 
+load_dotenv()
+ 
+# Environment config
+OPENWEATHERMAP_API_KEY = os.getenv("OPENWEATHERMAP_API_KEY")
+AWS_REGION = os.getenv("AWS_REGION", "us-east-1")
+ 
+# Bedrock Claude client
+bedrock = boto3.client("bedrock-runtime", region_name=AWS_REGION)
+ 
+# App UI
+st.title("Weather Assistant - Umbrella Advisor")
+st.markdown("Ask me if you should carry an umbrella tomorrow!")
+ 
+# Session state for chat
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+ 
+# Chat history display
+for msg in st.session_state.messages:
+    with st.chat_message(msg["role"]):
+        st.markdown(msg["content"])
+ 
+ 
+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}"
+    
+    try:
+        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."}
+        
+        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)}"}
+ 
+ 
+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.
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+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
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+When you need to get weather data, respond with this JSON format:
+{
+  "thought": "I need to get weather data for [location] to advise about umbrella",
+  "action": "get_weather",
+  "action_input": {"location": "city_name"}
+}
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+When you have all needed information, provide a conversational response that includes:
+- The location
+- Your reasoning based on weather conditions
+- Clear umbrella advice
 
-    messages.append({"role": "user", "content": message})
+Example: "You do not need to carry an umbrella tomorrow as the weather in New York will be sunny with no chance of rain."
 
-    response = ""
+If the user doesn't specify a location, ask them to specify it conversationally."""
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+    # Build conversation context
+    messages = [
+        {"role": "user", "content": f"{system_prompt}\n\nConversation history: {conversation_history}\n\nUser: {user_input}"}
+    ]
+    
+    claude_body = {
+        "anthropic_version": "bedrock-2023-05-31",
+        "max_tokens": 1000,
+        "temperature": 0.7,
+        "top_p": 0.9,
+        "messages": messages
+    }
+ 
+    response = bedrock.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:
+        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
+            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
+            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:
 
-        response += token
-        yield response
+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]."
 """
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+                
+                final_messages = [{"role": "user", "content": reasoning_prompt}]
+                
+                final_body = {
+                    "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)}"
+            
+    except json.JSONDecodeError:
+        # If not JSON, return the content as is (probably asking for location)
+        pass
+    
+    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 __name__ == "__main__":
-    demo.launch()
+if prompt := st.chat_input("Type your question here..."):
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(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.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.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
+    """)

requirements.txt

@@ -1 +1,10 @@
-huggingface_hub==0.25.2
+huggingface_hub==0.25.2
+qdrant_client
+streamlit
+boto3
+PyPDF2
+chromadb
+datasets
+
+streamlit
+boto3