Create app.py

app.py

@@ -0,0 +1,147 @@
+import os
+import gradio as gr
+from gradio import ChatMessage
+import requests
+from typing import Dict, List
+from langchain_core.messages import HumanMessage
+from langchain_core.tools import tool
+from langchain_openai import ChatOpenAI
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.prebuilt import create_react_agent
+
+# Weather and location tools
+@tool
+def get_lat_lng(location_description: str) -> dict[str, float]:
+    """Get the latitude and longitude of a location."""
+    if os.getenv("GEO_API_KEY") is None:
+        return {"lat": 51.1, "lng": -0.1}  # London coordinates as dummy response
+
+    params = {
+        "q": location_description,
+        "api_key": os.getenv("GEO_API_KEY"),
+    }
+    
+    r = requests.get("https://geocode.maps.co/search", params=params)
+    r.raise_for_status()
+    data = r.json()
+    
+    if data:
+        return {"lat": float(data[0]["lat"]), "lng": float(data[0]["lon"])}
+    else:
+        raise ValueError("Could not find the location")
+
+@tool
+def get_weather(lat: float, lng: float) -> dict[str, str]:
+    """Get the weather at a location."""
+    if not os.getenv("WEATHER_API_KEY"):
+        return {"temperature": "21°C", "description": "Sunny"}  # Dummy response
+        
+    params = {
+        "apikey": os.getenv("WEATHER_API_KEY"),
+        "location": f"{lat},{lng}",
+        "units": "metric",
+    }
+    
+    r = requests.get("https://api.tomorrow.io/v4/weather/realtime", params=params)
+    r.raise_for_status()
+    data = r.json()
+    
+    values = data["data"]["values"]
+    weather_codes = {
+        1000: "Clear, Sunny", 1100: "Mostly Clear", 1101: "Partly Cloudy",
+        1102: "Mostly Cloudy", 1001: "Cloudy", 2000: "Fog",
+        2100: "Light Fog", 4000: "Drizzle", 4001: "Rain",
+        4200: "Light Rain", 4201: "Heavy Rain", 5000: "Snow",
+        5001: "Flurries", 5100: "Light Snow", 5101: "Heavy Snow",
+        6000: "Freezing Drizzle", 6001: "Freezing Rain",
+        6200: "Light Freezing Rain", 6201: "Heavy Freezing Rain",
+        7000: "Ice Pellets", 7101: "Heavy Ice Pellets",
+        7102: "Light Ice Pellets", 8000: "Thunderstorm"
+    }
+    
+    return {
+        "temperature": f'{values["temperatureApparent"]:0.0f}°C',
+        "description": weather_codes.get(values["weatherCode"], "Unknown")
+    }
+
+def stream_from_agent(message: str, history: List[Dict[str, str]]) -> gr.ChatMessage:
+    """Process messages through the LangChain agent with visible reasoning."""
+    
+    # Initialize the agent
+    llm = ChatOpenAI(temperature=0, model="gpt-4")
+    memory = MemorySaver()
+    tools = [get_lat_lng, get_weather]
+    agent_executor = create_react_agent(llm, tools, checkpointer=memory)
+    
+    # Add message to history
+    past_messages = [HumanMessage(content=message)]
+    for h in history:
+        if h["role"] == "user":
+            past_messages.append(HumanMessage(content=h["content"]))
+    
+    messages_to_display = []
+    final_response = None
+    
+    for chunk in agent_executor.stream(
+        {"messages": past_messages},
+        config={"configurable": {"thread_id": "abc123"}}
+    ):
+        # Handle agent's actions and tool usage
+        if chunk.get("agent"):
+            for msg in chunk["agent"]["messages"]:
+                if msg.content:
+                    final_response = msg.content
+                
+                # Handle tool calls
+                for tool_call in msg.tool_calls:
+                    tool_message = ChatMessage(
+                        content=f"Parameters: {tool_call['args']}",
+                        metadata={
+                            "title": f"🛠️ Using {tool_call['name']}",
+                            "id": tool_call["id"],
+                            "status": "pending",
+                        }
+                    )
+                    messages_to_display.append(tool_message)
+                    yield messages_to_display
+                    tool_message.metadata["status"] = "done"
+                    
+        # Handle tool responses
+        if chunk.get("tools"):
+            for tool_response in chunk["tools"]["messages"]:
+                # Find the corresponding tool message
+                for msg in messages_to_display:
+                    if msg.metadata.get("id") == tool_response.tool_call_id:
+                        msg.content += f"\nResult: {tool_response.content}"
+                        yield messages_to_display
+    
+    # Add the final response as a regular message
+    if final_response:
+        messages_to_display.append(ChatMessage(content=final_response))
+        yield messages_to_display
+
+# Create the Gradio interface
+demo = gr.ChatInterface(
+    fn=stream_from_agent,
+    type="messages",
+    title="🌤️ Weather Assistant",
+    description="Ask about the weather anywhere! Watch as I gather the information step by step.",
+    examples=[
+        "What's the weather like in Tokyo?",
+        "Is it sunny in Paris right now?",
+        "Should I bring an umbrella in New York today?"
+    ],
+    #retry_btn="Retry ↺",
+    #undo_btn="Undo ↩",
+    #clear_btn="Clear 🗑️"
+)
+
+if __name__ == "__main__":
+    # Load environment variables
+    try:
+        from dotenv import load_dotenv
+        load_dotenv()
+    except ImportError:
+        pass
+
+    demo.launch(debug=True)