🌟 Building Stateful LLM Agents with LangGraph 🤖✨

LangGraph is a powerful library for building stateful, multi-actor applications with LLMs. By modeling LLM agent workflows as graphs, LangGraph enables developers to create flexible and interactive agent and multi-agent workflows.

In this article, we'll walk through building a simple agent using LangGraph, with OpenAI and TavilySearch as the core components. Both require API keys—TavilySearch offers free credits, while OpenAI requires you to add funds. 💸

🎉 Getting Started with LangGraph

To start, clone the repository: 👇

git clone https://github.com/CyprianTinasheAarons/basic-bot-langgraph

Set up the project environment: 🛠️

cd basic-bot
python -m venv .venv

Activate the virtual environment:

• On Windows:

  .venv\Scripts\activate

• On macOS and Linux:

  source .venv/bin/activate

Install dependencies: 📦

pip install -r requirements.txt

Set up environment variables: 🌱

• Copy .env.example to .env.
• Fill in your API keys in the .env file.

🛠️ Key Libraries and Configurations

Here are some of the key libraries that are required for our project:

import os
from typing import Literal
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import END, START, StateGraph, MessagesState
from langgraph.prebuilt import ToolNode
from dotenv import load_dotenv
from langchain_community.tools.tavily_search import TavilySearchResults
from loguru import logger

🔍 Configure Logging

We use Loguru to handle logging in this project:

# Configure loguru
logger.add("bot.log", rotation="10 MB")

🌐 Load Environment Variables

load_dotenv()
logger.info("Environment variables loaded")

🔧 Defining Tools and Nodes

Define the web search tool: 🔎

web_search = TavilySearchResults(max_results=2)

Define a function to perform a web search: 🌍

def search(query: str):
    """Call to surf the web."""
    logger.debug(f"Performing web search for query: {query}")
    return web_search.invoke({"query": query})

Define and create the tool node: 🛠️

tools = [search]

tool_node = ToolNode(tools)
logger.info("Tool node created")

🤖 Initializing the LLM Model

Here, we initialize an LLM using OpenAI's GPT-4: 🧠

llm = ChatOpenAI(model="gpt-4o", temperature=0, api_key=os.getenv("OPENAI_API_KEY"))
logger.info("LLM model initialized")

Bind the tools to the LLM: 🔗

llm_with_tools = llm.bind_tools(tools)

🔄 Defining Workflow Logic

Define a function that determines the conversation flow: 🔀

def should_continue(state: MessagesState) -> Literal["tools", END]:
    messages = state['messages']
    last_message = messages[-1]
    if last_message.tool_calls:
        logger.debug("Routing to tools node")
        return "tools"
    logger.debug("Ending conversation")
    return END

Define the function that calls the LLM model: 🗣️

def call_model(state: MessagesState):
    messages = state['messages']
    logger.debug(f"Calling LLM with {len(messages)} messages")
    response = llm_with_tools.invoke(messages)
    return {"messages": [response]}

🏗️ Building the Graph

Initialize the StateGraph: ⚙️

graph = StateGraph(MessagesState)
logger.info("StateGraph initialized")

Add nodes to the graph: ➕

graph.add_node("weatherbot", call_model)
graph.add_node("tools", tool_node)
logger.info("Nodes added to the graph")

Set the entry point: 🚪

graph.add_edge(START, "weatherbot")

Add conditional edges: 🔗

graph.add_conditional_edges("weatherbot", should_continue)

Add a normal edge from tools to weather bot: 🔄

graph.add_edge("tools", 'weatherbot')
logger.info("Graph edges configured")

Compile the graph: ✅

app = graph.compile()

logger.info("Graph compiled successfully")

📊 Saving Graph Visualization

try:

    graph_png = app.get_graph().draw_mermaid_png()

    with open("graph.png", "wb") as f:

        f.write(graph_png)

    logger.info("Graph visualization saved as graph.png")

except Exception as e:

    logger.error(f"Failed to save graph visualization: {e}")

🚀 Running the Agent

Invoke the app with a sample query: 🗨️

logger.info("Invoking the app with a sample query")

final_state = app.invoke(

    {"messages": [HumanMessage(content="what is the weather in sf")]},

    config={"configurable": {"thread_id": 42}}

)

🖥️ Usage

Run the bot using: 💻

python bot.py

🎉 Conclusion

Congratulations on building your first agent using LangGraph! 🎊 This is just the beginning of what you can achieve with LangGraph, LangChain, and LLMs. Stay tuned for more projects and tutorials exploring the exciting intersection of AI, LLMs, and agent workflows. 🚀🤗

Feel free to follow me on Twitter for more updates and projects. Also, check out my website here. 🌐✨

📚 Resources

• LangGraph Documentation
• LangChain Python Documentation