Building a Weather-Savvy AI Agent Using LangGraph, LangChain, and OpenAI

Have you ever wanted to build an AI assistant that can actually respond to questions about the weather using real-time data? In this blog post, I’ll show you how to build a smart agent that integrates LangGraph, LangChain, OpenAI, and a weather API to deliver real-time temperature updates.

We’ll build a conversational agent that:

✅ Understands your messages with GPT-4

✅ Detects when to use tools (like checking the weather)

✅ Returns the current temperature for any given location

Let’s dive in. 🌍🌦️

📦 Requirements

Before we begin, make sure you have the following Python packages installed:

pip install python-weather openai langchain langgraph python-dotenv 

Also, grab your OpenAI API key and pop it into a .env file like so:

OPENAI_API_KEY=your-api-key-here 

🧠 The Code

Step 1: Set Up Environment & Imports

We start by importing all the necessary libraries and loading our environment variables.

from dotenv import load_dotenv from openai import OpenAI import python_weather import asyncio from langgraph.graph import END, START, StateGraph, MessagesState from langchain_openai import ChatOpenAI from langchain_core.tools import tool from langgraph.prebuilt import ToolNode from typing import Literal load_dotenv() 

Step 2: Create a Weather Tool 🌡️

We use python_weather to fetch the current temperature asynchronously.

async def generate_response(location): async with python_weather.Client(unit=python_weather.IMPERIAL) as client: weather = await client.get(location) return weather.temperature @tool def get_weather(location: str): """Call to get the current temperature.""" return asyncio.run(generate_response(location)) 

This tool will later be integrated with our AI agent.

Step 3: Connect Tools to the Model

Next, we bind the get_weather tool to GPT-4 using LangChain’s ChatOpenAI.

tools = [get_weather] model = ChatOpenAI(model="gpt-4o-mini").bind_tools(tools) 

Step 4: Create the Agent Workflow using LangGraph

Here's where the magic happens! We define how the agent will think and act using a graph-based workflow.

def call_model(state: MessagesState): messages = state["messages"] response = model.invoke(messages) return {"messages": [response]} def should_continue(state: MessagesState) -> Literal["tools", END]: messages = state["messages"] last_message = messages[-1] if last_message.tool_calls: return "tools" return END workflow = StateGraph(MessagesState) tool_node = ToolNode(tools) workflow.add_node("agent", call_model) workflow.add_node("tools", tool_node) workflow.add_edge(START, "agent") workflow.add_conditional_edges("agent", should_continue) workflow.add_edge("tools", "agent") graph = workflow.compile() 

This setup allows the agent to:

1. Respond to user input
2. Decide if it needs a tool
3. Call the weather tool if needed
4. Respond again with the result

Step 5: Visualize the Workflow 🌐

If you're using Jupyter, visualize your agent's graph with Mermaid:

from IPython.display import Image, display from langchain_core.runnables.graph import MermaidDrawMethod display( Image( graph.get_graph().draw_mermaid_png( draw_method=MermaidDrawMethod.API, ) ) ) 

Step 6: Try It Out!

Let’s test how the agent responds to different types of messages.

from langchain_core.messages import HumanMessage messages1 = [HumanMessage(content="Hello, how are you?")] messages2 = [HumanMessage(content="How is the temperature in Lagos?")] graph.invoke({"messages": messages1}) graph.invoke({"messages": messages2}) 

You’ll see GPT-4 respond conversationally to the first, and call the weather tool for the second. 🎯

🚀 Wrap-Up

You now have a fully functioning conversational AI agent that can:

✅ Understand user intent

✅ Decide when to use external tools

✅ Fetch real-time weather data

✅ Reply intelligently using GPT-4

This is just scratching the surface. You could add more tools (news, calendar, reminders) and turn this into a real personal assistant.

Got questions or building something similar? Drop a comment below! 🧠💬

Happy coding!