weather app using pydanticai

app.py

@@ -0,0 +1,525 @@
+import streamlit as st
+
+st.markdown("""
+             **Weather agent**
+             
+            Example of PydanticAI with `multiple tools` which the LLM needs to call in turn to answer a question.
+             """)
+
+with st.expander("🎯 Objectives"):
+    st.markdown("""
+    - Use **OpenAI GPT-4o-mini** agent to `process natural language queries` about the weather.
+    - Fetch **geolocation** from a location string using the `Maps.co API`.
+    - Retrieve **real-time weather** using the Tomorrow.io API.
+    - Handle `retries`, `backoff`, and `logging` using **Logfire**.
+    - Integrate all parts in a clean, async-compatible **Streamlit UI**.
+    - Ensuring `concise` and `structured` responses.
+    """)
+
+with st.expander("🧰 Pre-requisites"):
+    st.markdown("""
+    - Python 3.10+
+    - Streamlit
+    - AsyncClient (httpx)
+    - OpenAI `pydantic_ai` Agent
+    - Logfire for tracing/debugging
+    - Valid API Keys:
+      - [https://geocode.maps.co/](https://geocode.maps.co/)
+      - [https://www.tomorrow.io/](https://www.tomorrow.io/)
+    """)
+    
+    st.code("""
+    pip install streamlit httpx logfire pydantic_ai
+    """)
+
+with st.expander("⚙️ Step-by-Step Setup"):
+    st.markdown("**Imports and Global Client**")
+    st.code("""
+            import os
+            import asyncio
+            import streamlit as st
+            from dataclasses import dataclass
+            from typing import Any
+            import logfire
+            from httpx import AsyncClient
+            from pydantic_ai import Agent, RunContext, ModelRetry
+
+            logfire.configure(send_to_logfire='if-token-present')
+            client = AsyncClient()
+    """)
+
+    st.markdown("**Declare Dependencies**")
+    st.code("""
+        @dataclass
+        class Deps:
+            client: AsyncClient          # client is an instance of AsyncClient (from httpx).
+            weather_api_key: str | None
+            geo_api_key: str | None
+        """)
+
+    st.markdown("**Setup Weather Agent**")
+    st.code("""
+        weather_agent = Agent(
+            'openai:gpt-4o-mini',
+            system_prompt=(
+                'Be concise, reply with one sentence. '
+                'Use the `get_lat_lng` tool to get the latitude and longitude of the locations, '
+                'then use the `get_weather` tool to get the weather.'
+            ),
+            deps_type= Deps,
+            retries  = 2,
+        )
+    """)
+
+    st.markdown("**Define Geocoding Tool with Retry**")
+    st.code("""
+        @weather_agent.tool
+        async def get_lat_lng(ctx: RunContext[Deps], 
+                              location_description: str,
+                              max_retries: int = 5, 
+                              base_delay: int = 2) -> dict[str, float]:
+            "Get the latitude and longitude of a location with retry handling for rate limits."
+            
+            if ctx.deps.geo_api_key is None:
+                return {'lat': 51.1, 'lng': -0.1}  # Default to London
+
+            # Sets up API request parameters.
+            params = {'q': location_description, 'api_key': ctx.deps.geo_api_key}
+
+            # Loops for a maximum number of retries.
+            for attempt in range(max_retries):
+                try:
+                
+                    # Logs API call span with parameters.
+                    with logfire.span('calling geocode API', params=params) as span:
+                        
+                        # Sends async GET request.
+                        r = await ctx.deps.client.get('https://geocode.maps.co/search', params=params)
+
+                        # Checks if API rate limit is exceeded.
+                        if r.status_code == 429:
+                        
+                            # Exponential backoff
+                            wait_time = base_delay * (2 ** attempt)
+                            
+                            # Waits before retrying.
+                            await asyncio.sleep(wait_time)
+                            
+                            # Continues to the next retry attempt.
+                            continue
+
+                        r.raise_for_status()
+                        data = r.json()
+                        span.set_attribute('response', data)
+
+                    if data:
+                        # Extracts and returns latitude & longitude.
+                        return {'lat': float(data[0]['lat']), 'lng': float(data[0]['lon'])}
+                    else:
+                        # Raises an error if no valid data is found.
+                        raise ModelRetry('Could not find the location')
+
+                except Exception as e:                  # Catches HTTP errors.
+                    print(f"Request failed: {e}")       # Logs the failure.
+
+            raise ModelRetry('Failed after multiple retries')
+            
+            """)
+
+    st.markdown("**Define Weather Tool**")
+    st.code("""
+        @weather_agent.tool
+        async def get_weather(ctx: RunContext[Deps], lat: float, lng: float) -> dict[str, Any]:
+            if ctx.deps.weather_api_key is None:
+                return {'temperature': '21 °C', 'description': 'Sunny'}
+            params = {'apikey': ctx.deps.weather_api_key, 'location': f'{lat},{lng}', 'units': 'metric'}
+            
+            r = await ctx.deps.client.get('https://api.tomorrow.io/v4/weather/realtime', params=params)
+            r.raise_for_status()
+            
+            data = r.json()
+            values = data['data']['values']
+
+            code_lookup = {
+                1000: 'Clear, Sunny', 1001: 'Cloudy', 1100: 'Mostly Clear', 1101: 'Partly Cloudy',
+                1102: 'Mostly 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': code_lookup.get(values['weatherCode'], 'Unknown'),
+            }
+            """)
+
+    st.markdown("**Wrapper to Run the Agent**")
+    st.code("""
+        async def run_weather_agent(user_input: str):
+            deps = Deps(
+                client=client,
+                weather_api_key = os.getenv("TOMORROW_IO_API_KEY"),
+                geo_api_key     = os.getenv("GEOCODE_API_KEY")
+            )
+            result = await weather_agent.run(user_input, deps=deps)
+            return result.data
+    """)
+
+    st.markdown("**Streamlit UI with Async Handling**")
+    st.code("""
+        st.set_page_config(page_title="Weather Application", page_icon="🚀")
+
+        if "weather_response" not in st.session_state:
+            st.session_state.weather_response = None
+
+        st.title("Weather Agent App")
+        user_input = st.text_area("Enter a sentence with locations:", "What is the weather like in Bangalore, Chennai and Delhi?")
+
+        if st.button("Get Weather"):
+            with st.spinner("Fetching weather..."):
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                response = loop.run_until_complete(run_weather_agent(user_input))
+                st.session_state.weather_response = response
+
+        if st.session_state.weather_response:
+            st.info(st.session_state.weather_response)
+    """)
+
+with st.expander("Description of Each Step"):
+    st.markdown("""
+    - **Imports**: Brings in all required packages including `httpx`, `logfire`, and `streamlit`.
+    - **`Deps` Dataclass**: Encapsulates dependencies injected into the agent like the API keys and shared HTTP client.
+    - **Weather Agent**: Configures an OpenAI GPT-4o-mini agent with tools for geolocation and weather.
+    - **Tools**:
+        - `get_lat_lng`: Geocodes a location using a free Maps.co API. Implements retry with exponential backoff.
+        - `get_weather`: Fetches live weather info from Tomorrow.io using lat/lng.
+    - **Agent Runner**: Wraps the interaction to run asynchronously with injected dependencies.
+    - **Streamlit UI**: Captures user input, triggers agent execution, and displays response with `asyncio`.
+    """)
+    
+    st.image("https://raw.githubusercontent.com/gridflowai/gridflowAI-datasets-icons/862001d5ac107780b38f96eca34cefcb98c7f3e3/AI-icons-images/get_weather_app.png",
+         caption="Agentic Weather App Flow",
+         use_column_width=True)
+    
+
+import os
+import asyncio
+import streamlit as st
+from dataclasses import dataclass
+from typing import Any
+
+import logfire
+from httpx import AsyncClient
+from pydantic_ai import Agent, RunContext, ModelRetry
+
+# Configure logfire
+logfire.configure(send_to_logfire='if-token-present')
+
+@dataclass
+class Deps:
+    client: AsyncClient
+    weather_api_key: str | None
+    geo_api_key: str | None
+    
+weather_agent = Agent(
+    'openai:gpt-4o-mini',
+    system_prompt=(
+        'Be concise, reply with one sentence. '
+        'Use the `get_lat_lng` tool to get the latitude and longitude of the locations, '
+        'then use the `get_weather` tool to get the weather.'
+    ),
+    deps_type=Deps,
+    retries=2,
+)
+
+# Create a single global AsyncClient instance
+client = AsyncClient()
+
+@weather_agent.tool
+async def get_lat_lng(ctx: RunContext[Deps], 
+                      location_description: str,
+                      max_retries: int = 5, 
+                      base_delay: int = 2) -> dict[str, float]:
+    """Get the latitude and longitude of a location."""
+    
+    if ctx.deps.geo_api_key is None:
+        return {'lat': 51.1, 'lng': -0.1}  # Default to London
+
+    # Sets up API request parameters.
+    params = {'q': location_description, 'api_key': ctx.deps.geo_api_key}
+
+    # Loops for a maximum number of retries.
+    for attempt in range(max_retries):
+        try:
+            # Logs API call span with parameters.
+            with logfire.span('calling geocode API', params=params) as span:
+
+                # Sends async GET request.
+                r = await ctx.deps.client.get('https://geocode.maps.co/search', params=params)
+
+                # Checks if API rate limit is exceeded.
+                if r.status_code == 429:  # Too Many Requests
+                    wait_time = base_delay * (2 ** attempt)  # Exponential backoff
+                    print(f"Rate limited. Retrying in {wait_time} seconds...")
+
+                    # Waits before retrying.
+                    await asyncio.sleep(wait_time)
+
+                    # Continues to the next retry attempt.
+                    continue  # Retry the request
+
+                # Raises an exception for HTTP errors.
+                r.raise_for_status()
+
+                # Parses the API response as JSON.
+                data = r.json()
+
+                # Logs the response data.
+                span.set_attribute('response', data)
+
+            if data:
+                # Extracts and returns latitude & longitude.
+                return {'lat': float(data[0]['lat']), 'lng': float(data[0]['lon'])}
+            else:
+                # Raises an error if no valid data is found.
+                raise ModelRetry('Could not find the location')
+
+        except Exception as e:     # Catches HTTP errors.
+            print(f"Request failed: {e}")      # Logs the failure.
+
+    raise ModelRetry('Failed after multiple retries')
+
+@weather_agent.tool
+async def get_weather(ctx: RunContext[Deps], lat: float, lng: float) -> dict[str, Any]:
+    """Get the weather at a location."""
+    if ctx.deps.weather_api_key is None:
+        return {'temperature': '21 °C', 'description': 'Sunny'}
+    params = {'apikey': ctx.deps.weather_api_key, 'location': f'{lat},{lng}', 'units': 'metric'}
+    
+    r = await ctx.deps.client.get('https://api.tomorrow.io/v4/weather/realtime', params=params)
+    
+    r.raise_for_status()
+    
+    data = r.json()
+    
+    values = data['data']['values']
+    
+    code_lookup = {
+        1000: 'Clear, Sunny', 1001: 'Cloudy', 1100: 'Mostly Clear', 1101: 'Partly Cloudy',
+        1102: 'Mostly 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': code_lookup.get(values['weatherCode'], 'Unknown'),
+    }
+    
+async def run_weather_agent(user_input: str):
+    deps = Deps(
+        client=client,  # Use global client
+        weather_api_key=os.getenv("TOMORROW_IO_API_KEY"),
+        geo_api_key=os.getenv("GEOCODE_API_KEY")
+    )
+    result = await weather_agent.run(user_input, deps=deps)
+    return result.data
+
+# Initialize session state for storing weather responses
+if "weather_response" not in st.session_state:
+    st.session_state.weather_response = None
+    
+# Set the page title
+#st.set_page_config(page_title="Weather Application", page_icon="🚀")
+
+# Streamlit UI
+with st.expander(f"**Example prompts**"):
+
+    st.markdown(f"""
+                
+        Prompt : If I were in Sydney today, would I need a jacket?
+        Bot : No, you likely wouldn't need a jacket as it's clear and sunny with a temperature of 22°C in Sydney.
+
+        Prompt : Tell me whether it's beach weather in Bali and Phuket.
+        Bot : Bali is too cold at 7°C and partly cloudy for beach weather, while Phuket is warm at 26°C with drizzle, making it more suitable for beach activities.
+
+        Prompt : If I had a meeting in Dubai, should I wear light clothing?
+        Bot : Yes, you should wear light clothing as the temperature in Dubai is currently 25°C and mostly clear.
+
+        Prompt : How does today’s temperature in Tokyo compare to the same time last week?
+        Bot : Today's temperature in Tokyo is 14°C, which is the same as the temperature at the same time last week.
+
+        Prompt : Is the current weather suitable for air travel in London and New York?
+        Bot : The current weather in London is 5°C and cloudy, and in New York, it is -0°C and clear; both conditions are generally suitable for air travel.
+        
+        """)
+
+user_input = st.text_area("Enter a sentence with locations:", "What is the weather like in Bangalore, Chennai and Delhi?")
+
+# Button to trigger weather fetch
+if st.button("Get Weather"):
+    with st.spinner("Fetching weather..."):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        response = loop.run_until_complete(run_weather_agent(user_input))
+        st.session_state.weather_response = response
+
+# Display stored response
+if st.session_state.weather_response:
+    st.info(st.session_state.weather_response)
+    
+        
+with st.expander("🧠 How is this app Agentic?"):
+    st.markdown("""
+    ###### ✅ How this App is Agentic
+
+    This weather app demonstrates **Agentic AI** because:
+
+    1. **Goal-Oriented Autonomy**  
+       The user provides a natural language request (e.g., *“What’s the weather in Bangalore and Delhi?”*).  
+       The agent autonomously figures out *how* to fulfill it.
+
+    2. **Tool Usage by the Agent**  
+       The `Agent` uses two tools:
+       - `get_lat_lng()` – to fetch coordinates via a geocoding API.
+       - `get_weather()` – to get real-time weather for those coordinates.  
+       The agent determines when and how to use these tools.
+
+    3. **Context + Dependency Injection**  
+       The app uses the `Deps` dataclass to provide the agent with shared dependencies like HTTP clients and API keys—just like a human agent accessing internal tools.
+
+    4. **Retries and Adaptive Behavior**  
+       The agent handles failures and retries via `ModelRetry`, showing resilience and smart retry logic.
+
+    5. **Structured Interactions via `RunContext`**  
+       Each tool runs with access to structured context, enabling better coordination and reuse of shared state.
+
+    6. **LLM-Orchestrated Actions**  
+       At the core, a GPT-4o-mini model orchestrates:
+       - Understanding the user intent,
+       - Selecting and invoking the right tools,
+       - Synthesizing the final response.
+
+    > 🧠 **In essence**: This is not just a chatbot, but an *autonomous reasoning engine* that uses real tools to complete real-world goals.
+    """)
+    
+with st.expander("🧪 Example Prompts: Handling Complex Queries"):
+    st.markdown("""
+    This app can understand **natural, varied, and multi-part prompts** thanks to the LLM-based agent at its core.  
+    It intelligently uses `get_lat_lng()` and `get_weather()` tools based on user intent.
+
+    ###### 🗣️ Complex Prompt Examples & Responses:
+
+    **Prompt:**  
+    *If I were in Sydney today, would I need a jacket?*  
+    **Response:**  
+    *No, you likely wouldn't need a jacket as it's clear and sunny with a temperature of 22°C in Sydney.*
+
+    ---
+
+    **Prompt:**  
+    *Tell me whether it's beach weather in Bali and Phuket.*  
+    **Response:**  
+    *Bali is too cold at 7°C and partly cloudy for beach weather, while Phuket is warm at 26°C with drizzle, making it more suitable for beach activities.*
+
+    ---
+
+    **Prompt:**  
+    *If I had a meeting in Dubai, should I wear light clothing?*  
+    **Response:**  
+    *Yes, you should wear light clothing as the temperature in Dubai is currently 25°C and mostly clear.*
+
+    ---
+
+    **Prompt:**  
+    *How does today’s temperature in Tokyo compare to the same time last week?*  
+    **Response:**  
+    *Today's temperature in Tokyo is 14°C, which is the same as the temperature at the same time last week.*  
+    *(Note: This would require historical API support to be accurate in a real app.)*
+
+    ---
+
+    **Prompt:**  
+    *Is the current weather suitable for air travel in London and New York?*  
+    **Response:**  
+    *The current weather in London is 5°C and cloudy, and in New York, it is -0°C and clear; both conditions are generally suitable for air travel.*
+
+    ---
+
+    **Prompt:**  
+    *Give me the weather update for all cities where cricket matches are happening today in India.*  
+    **Response:**  
+    *(This would involve external logic for identifying cricket venues, but the agent can handle the weather lookup part once cities are known.)*
+
+    ---
+
+    ###### 🧠 Why it Works:
+    - The **agent extracts all cities** from the prompt, even if mixed with unrelated text.
+    - It **chains tool calls**: First gets geolocation, then weather.
+    - The **final response is LLM-crafted** to match the tone and question format (yes/no, suggestion, comparison, etc.).
+
+    > ✅ You don’t need to ask "what's the weather in X" exactly — the agent infers it from how humans speak.
+    """)
+    
+with st.expander("🔍 Missing Agentic AI Capabilities & How to Improve"):
+    st.markdown("""
+    While the app exhibits several **agentic behaviors**—like tool use, intent recognition, and multi-step reasoning—it still lacks **some core features** found in *fully agentic systems*. Here's what’s missing:
+
+    ###### ❌ Missing Facets & How to Add Them
+
+    **1. Autonomy & Proactive Behavior**  
+    *Current:* The app only responds to user prompts.  
+    *To Add:* Let the agent proactively ask follow-ups.  
+    **Example:**  
+    - User: *What's the weather in Italy?*  
+    - Agent: *Italy has multiple cities. Would you like weather in Rome, Milan, or Venice?*
+
+    **2. Goal-Oriented Planning**  
+    *Current:* Executes one tool or a fixed chain of tools.  
+    *To Add:* Give it a higher-level goal and let it plan the steps.  
+    **Example:**  
+    - Prompt: *Help me plan a weekend trip to a warm place in Europe.*  
+    - Agent: Finds warm cities, checks weather, compares, and recommends.
+
+    **3. Memory / Session Context**  
+    *Current:* Stateless; each query is standalone.  
+    *To Add:* Use LangGraph or crewAI memory modules to **remember past queries** or preferences.  
+    **Example:**  
+    - User: *What’s the weather in Delhi?*  
+    - Then: *And how about tomorrow?* → Agent should know the context refers to Delhi.
+
+    **4. Delegation to Sub-Agents**  
+    *Current:* Single-agent, monolithic logic.  
+    *To Add:* Delegate tasks to specialized agents (geocoder agent, weather formatter agent, response stylist, etc.).  
+    **Example:**  
+    - Planner agent decides cities → Fetcher agent retrieves data → Explainer agent summarizes.
+
+    **5. Multi-Modal Input/Output**  
+    *Current:* Only text.  
+    *To Add:* Accept voice prompts or generate a weather infographic.  
+    **Example:**  
+    - Prompt: *Voice note saying "Is it rainy in London?"* → Returns image with rainy clouds and summary.
+
+    **6. Learning from Feedback**  
+    *Current:* No learning or improvement from user input.  
+    *To Add:* Allow thumbs up/down or feedback to tune responses.  
+    **Example:**  
+    - User: *That was not helpful.* → Agent: *Sorry! Want a more detailed report or city breakdown?*
+
+    ---
+
+    ###### ✅ Summary
+    This app **lays a strong foundation for Agentic AI**, but adding these elements would bring it closer to a **truly autonomous, context-aware, and planning-capable agent** that mimics human-level task execution.
+    """)
+
+    
+    
+
+
+
+
+

requirements.txt

@@ -0,0 +1,6 @@
+openai
+httpx
+pydantic
+pydantic-ai
+logfire
+python-dotenv