langgraph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Langgraph\n",
    "\n",
    "In this notebook, we will learn the basics of langgraph and how to create a basic workflow using langgraph. We will also create one mini project with crewAI and Langgraph to understand it in more detail.\n",
    "\n",
    "First of all let's create a basic workflow using langgraph. So let's start by installing the required dependencies\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install langgraph langchain openai langchain_openai langchain_community pyowm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use open weather API to get information about weather information of any location. You can get your own API key from their website for free. Additionally, you will also require OpenAI API key to use their LLM.\n",
    "\n",
    "Store your openweather and OpenAI API keys in environment variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['OPENAI_API_KEY'] = openai_secret\n",
    "os.environ[\"OPENWEATHERMAP_API_KEY\"] = openweather_secret"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use “OpenWeatherMapAPIWrapper()” to make a call to OpenWeather API and we will use “ChatOpenAI” to use GPT-3.5 model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_openai import ChatOpenAI\n",
    "from langchain_community.utilities import OpenWeatherMapAPIWrapper\n",
    "openai_llm = ChatOpenAI(temperature=0.4)\n",
    "weather = OpenWeatherMapAPIWrapper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will create one node which will take user input and extract the city name from user’s query and pass it to next node where we will get the weather information using openweather wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Node to extract city from user input\n",
    "def agent(input_1):\n",
    "  res = openai_llm.invoke(f\"\"\"\n",
    "  You are given one question and you have to extract city name from it\n",
    "  Don't respond anything except the city name and don't reply anything if you can't find city name\n",
    "\n",
    "  Here is the question:\n",
    "  {input_1}\n",
    "  \"\"\")\n",
    "  return res.content\n",
    "  \n",
    "# Node to find weather information\n",
    "def weather_tool(input_2):\n",
    "  data = weather.run(input_2)\n",
    "  return data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let’s connect these 2 nodes using edges and create a graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.graph import Graph\n",
    "workflow = Graph()\n",
    "\n",
    "workflow.add_node(\"agent\", agent)\n",
    "workflow.add_node(\"weather\", weather_tool)\n",
    "\n",
    "# Connecting 2 nodes\n",
    "workflow.add_edge('agent', 'weather')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is how our workflow will look like 👇\n",
    "![](https://assets-global.website-files.com/62528d398a42420e66390ef9/6641f6f8558143699a109f3b_image3.png)\n",
    "\n",
    "Additionally, you can define the starting and ending points of your workflow. Here we know that our input will be passed to an agent and then we will find the weather info so the starting point will be the agent node and the ending point will be the weather node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "workflow.set_entry_point(\"agent\")\n",
    "workflow.set_finish_point(\"weather\")\n",
    "\n",
    "app = workflow.compile()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally, let’s run our langgraph!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "app.invoke(\"What is weather in delhi?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And you will get output like this\n",
    "\n",
    "```\n",
    "In Delhi, the current weather is as follows:\n",
    "Detailed status: haze\n",
    "Wind speed: 3.6 m/s, direction: 80°\n",
    "Humidity: 34%\n",
    "Temperature: \n",
    "  - Current: 37.05°C\n",
    "  - High: 37.05°C\n",
    "  - Low: 37.05°C\n",
    "  - Feels like: 39.1°C\n",
    "Rain: {}\n",
    "Heat index: None\n",
    "Cloud cover: 0%\n",
    "```\n",
    "\n",
    "But the output is not properly readable, what if we have a responder node that will format this output properly and work as a weather agent instead of a function.\n",
    "\n",
    "Let’s add a new node called ‘responder’ which will format the weather tool output and provide better results. But wait 🤔, we will need the user’s query to properly format our answer but we will only get the weather tool output in our node so how can we get the user’s query which we are passing to agent node? 👀\n",
    "\n",
    "This is where states comes into picture. We will create one state called “messages” which will store all the conversation happening in the entire workflow. so let’s create it first!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will keep adding our conversation in this list\n",
    "from typing import TypedDict, Annotated, Sequence\n",
    "import operator\n",
    "class AgentState(TypedDict):\n",
    "    messages: Annotated[Sequence[str], operator.add]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now let’s create our third node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def responder(state):\n",
    "  agent = openai_llm.invoke(f\"\"\"\n",
    "  You have given a weather information and you have to respond to user's query based on the information\n",
    "\n",
    "  Here is the user query:\n",
    "  ---\n",
    "  {state[\"messages\"][0]}\n",
    "  ---\n",
    "\n",
    "  Here is the information:\n",
    "  ---\n",
    "  {state[\"messages\"][2]}\n",
    "  ---\n",
    "  \"\"\")\n",
    "  return {\"messages\": [agent.content]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure first 2 nodes are also using state and adding their responses in messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def agent(state):\n",
    "  query = state[\"messages\"]\n",
    "  res = openai_llm.invoke(f\"\"\"\n",
    "  You are given one question and you have to extract city name from it\n",
    "\n",
    "  Only reply the city name if it exists or reply 'no_response' if there is no city name in question\n",
    "\n",
    "  Here is the question:\n",
    "  {query[0]}\n",
    "  \"\"\")\n",
    "  return {\"messages\":[res.content]}\n",
    "\n",
    "def weather_tool(state):\n",
    "  context = state[\"messages\"]\n",
    "  city_name = context[1]\n",
    "  data = weather.run(city_name)\n",
    "  return {\"messages\": [data]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally let’s create a stateful graph as we have state to pass between nodes. Also define nodes and connect them using edges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.graph import StateGraph\n",
    "workflow = StateGraph(AgentState)\n",
    "workflow.add_node('agent',agent)\n",
    "workflow.add_node('weather',weather_tool)\n",
    "workflow.add_node(\"responder\",responder)\n",
    "\n",
    "# Connect the nodes\n",
    "workflow.add_edge('agent', 'weather')\n",
    "workflow.add_edge('weather', 'responder')\n",
    "\n",
    "# Set entry and finish point\n",
    "workflow.set_entry_point(\"agent\")\n",
    "workflow.set_finish_point(\"responder\")\n",
    "app = workflow.compile()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how the new workflow will look like 👇\n",
    "![](https://assets-global.website-files.com/62528d398a42420e66390ef9/6641f7d993f204bc6be3def1_image4.png)\n",
    "\n",
    "Let’s try it with responder!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = {\"messages\": [\"What is weather in delhi?\"]}\n",
    "response = app.invoke(inputs)\n",
    "print(response['messages'][-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now the agent will reply in more readable way\n",
    "\n",
    "`In Delhi, the current weather is hazy with a temperature of 37.05°C. The wind speed is 3.6 m/s coming from the direction of 80°. The humidity is at 34% and there is no rain expected. The cloud cover is at 0% and it currently feels like 39.1°C.`\n",
    "\n",
    "You can also ask specific questions like “Is there any chance of rain in delhi?” or “Is it a best weather to go on long drive in delhi?” and responder will respond accordingly.\n",
    "\n",
    "Still there is a one problem 💀, the agent still can’t answer questions like “How are you?” because it will try to find a city name in it and if it can’t find it then weather tool will throw an error so we will have to handle this case too.\n",
    "\n",
    "![](https://assets-global.website-files.com/62528d398a42420e66390ef9/6641f828beb30e36fa4deba1_image5.png)\n",
    "\n",
    "What if we run weather tool conditionally? 🤔, means we will only run that tool when user asks weather information otherwise we will not respond anything. This is where we will need to create a conditional edge so let’s create one!\n",
    "\n",
    "We will tell our llm to response with “no_response” if it can’t find city name in user query and based on that output, we will use weather tool or end the workflow.\n",
    "\n",
    "This is how the updated workflow will look like 👇\n",
    "\n",
    "![](https://assets-global.website-files.com/62528d398a42420e66390ef9/6641f8542404f91709fe6519_image6.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.graph import Graph, END\n",
    "# Defining condition function\n",
    "def where_to_go(state):\n",
    "  ctx = messages[0]\n",
    "  if ctx == \"no_response\":\n",
    "    return \"end\"\n",
    "  else:\n",
    "    return \"continue\"\n",
    "  \n",
    "# Create an conditional edge\n",
    "workflow.add_conditional_edges('agent',where_to_go,{\n",
    "    \"end\": END,\n",
    "    \"continue\": \"weather_tool\"\n",
    "})\n",
    "# Remaining edges\n",
    "workflow.add_edge(\"weather_tool\",\"responder\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now if we ask questions like “How are you?” then it will respond with “no_response” instead of throwing an error and if you ask questions regarding weather information then it will use weather tool and respond with responder 🚀!\n",
    "\n",
    "Now we know how to create a basic workflow using langgraph so let’s get our hand dirty by creating a multi purpose AI agent👀!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini Project: Let’s Create a Multi-Purpose AI Agent\n",
    "Let’s create an AI agent that can give us live weather information, create draft replies for our emails or even it can chat with us normally like a chatbot. You can add more workflows in this agent but for the simplicity of this blog I am only going to add 2 workflows. So let’s get started 🚀!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Workflow\n",
    "Before creating the project, let’s take a look at the workflow of our agent!\n",
    "![](https://assets-global.website-files.com/62528d398a42420e66390ef9/6641f8896dd1ef4f1d90e806_image7.png)\n",
    "\n",
    "We will first add the user input in our entry node where the user input will be categorized into 3 categories:\n",
    "\n",
    "- email_query: If user want to generate an email response to given email\n",
    "- weather_query: If user want weather information about any location\n",
    "- other: If user want any other information\n",
    "\n",
    "Now based on the categories, we will redirect the query to right node. 🔂\n",
    "\n",
    "We will use CrewAI to create a crew which can categorize the email and then based on the category it will write a response. We will also create an separate agent for weather where we will provide the openweather function as a tool and it will automatically format the final weather information response. For all other queries, we will just make a simple OpenAI call."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prerequisites\n",
    "Here are the things you will need to create this project\n",
    "\n",
    "- OpenAI API key\n",
    "- Openweather API key\n",
    "- A basic knowledge about CrewAI (If you don’t know about CrewAI then I suggest you to take a look at my blog about CrewAI)\n",
    "\n",
    "Add your API keys in environment variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['OPENAI_API_KEY'] = openai_secret\n",
    "os.environ[\"OPENWEATHERMAP_API_KEY\"] = openweather_secret"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now we have everything ready, let’s get back to coding 💻!\n",
    "\n",
    "### Let’s code it\n",
    "\n",
    "First of all, let’s install required dependencies!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install langgraph langchain openai langchain_openai langchain_community pyowm crewai"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s initialize ChatOpenAI and OpenweatherWrapper objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_openai import ChatOpenAI\n",
    "from langchain_community.utilities import OpenWeatherMapAPIWrapper\n",
    "openai_llm = ChatOpenAI(temperature=0.4)\n",
    "weather = OpenWeatherMapAPIWrapper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s import required packages and modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import required dependencies\n",
    "from crewai import Crew, Agent, Task\n",
    "from textwrap import dedent\n",
    "import os\n",
    "import json\n",
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before creating agents or workflows, let’s first define the states which we are going to pass among nodes.\n",
    "\n",
    "We will use these state variables in our workflow 👇\n",
    "\n",
    "- messages: It will store the conversation history to keep track of conversation happening in workflow between agents\n",
    "- email: If user want to generate a email response then entry node will extract the email body from user input and add it in this state\n",
    "- query: It will store the user’s query\n",
    "- category: It will store the category of user’s query ( email_query, weather_query or other )\n",
    "\n",
    "Let’s write the code to define our states:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import TypedDict\n",
    "class AgentState(TypedDict):\n",
    "    messages: list[str]\n",
    "    email: str\n",
    "    query: str\n",
    "    category: str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First let’s create our email crew which will have 2 agents: ClassifierAgent and emailWriterAgent\n",
    "\n",
    "ClassifierAgent will classify the given email in Important or Casual Category and emailWriterAgent will generate response based on the category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agents:\n",
    "\tdef classifierAgent():\n",
    "\t    return Agent(\n",
    "\t      role='Email Classifier',\n",
    "\t      goal='You will be given an email and you have to classify the given email in one of these 2 categories: 1) Important 2) Casual ',\n",
    "\t      backstory='An email classifier who is expert in classifying every type of email and have classified so many emails so far',\n",
    "\t      verbose = True,\n",
    "\t      allow_delegation=False,\n",
    "\t    )\n",
    "\tdef emailWriterAgent():\n",
    "\t  return Agent(\n",
    "\t    role='Email writing expert',\n",
    "\t    goal=\"You are email writing assistant for Shivam. You will be given an email and a category of that email and your job is to write a reply for that email. If email category is 'Important' then write the reply in professional way and If email category is 'Casual' then write in a casual way\",\n",
    "\t    backstory='An email writer with an expertise in email writing for more than 10 years',\n",
    "\t    verbose = True,\n",
    "\t    allow_delegation=False,\n",
    "\t  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let’s create the tasks for these agents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tasks:\n",
    "\tdef classificationTask(agent,email):\n",
    "\t    return Task(\n",
    "\t        description=dedent(f\"\"\"\n",
    "\t        You have given an email and you have to classify this email\n",
    "\t        {email}\n",
    "\t        \"\"\"),\n",
    "\t        agent = agent,\n",
    "\t        expected_output = \"Email category as a string\"\n",
    "\t    )\n",
    "\tdef writerTask(agent,email):\n",
    "\t  return Task(\n",
    "\t      description=dedent(f\"\"\"\n",
    "\t      Create an email response to the given email based on the category provided by 'Email Classifier' Agent\n",
    "\t      {email}\n",
    "\t      \"\"\"),\n",
    "\t      agent = agent,\n",
    "\t      expected_output = \"A very concise response to the email based on the category provided by 'Email Classifier' Agent\"\n",
    "\t  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally let’s create our email crew"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EmailCrew:\n",
    "  def __init__(self,email):\n",
    "    self.email = email\n",
    "  def run(self):\n",
    "\t\t# Agents\n",
    "    classifierAgent = Agents.classifierAgent()\n",
    "    writerAgent = Agents.emailWriterAgent()\n",
    "\t\t# Tasks\n",
    "    classifierTask = Tasks.classificationTask(agent=classifierAgent,email=self.email)\n",
    "    writerTask = Tasks.writerTask(agent=writerAgent,email=self.email)\n",
    "\t\t# Create crew\n",
    "    crew = Crew(\n",
    "      agents=[classifierAgent,writerAgent],\n",
    "      tasks=[classifierTask,writerTask],\n",
    "      verbose=2, # You can set it to 1 or 2 to different logging levels\n",
    "    )\n",
    "\t\t# Run the crew\n",
    "    result = crew.kickoff()\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let’s create a node where we will run this crew"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Nodes:\n",
    "  def writerNode(self,state):\n",
    "    email = state[\"email\"]\n",
    "    emailCrew = EmailCrew(email)\n",
    "    crewResult = emailCrew.run()\n",
    "    messages = state[\"messages\"]\n",
    "    messages.append(crewResult)\n",
    "    return {\"messages\": messages}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let’s create our weather agent workflow 🌤️\n",
    "\n",
    "We will create a weather tool which will use openweather wrapper to get the weather information. We will assign this tool to our weather agent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.tools import tool\n",
    "class Tools:\n",
    "  @tool(\"Tool to get the weather of any location\")\n",
    "  def weather_tool(location):\n",
    "    \"\"\"\n",
    "    Use this tool when you have given a location and you want to find the weather of that location\n",
    "    \"\"\"\n",
    "    data = weather.run(location)\n",
    "    return data\n",
    "    \n",
    "class Agents:\n",
    "\t# ... Other agents\n",
    "  def weatherAgent():\n",
    "    return Agent(\n",
    "          role = 'Weather Expert',\n",
    "          goal = 'You will be given a location name and you have to find the weather information about that location using the tools provided to you',\n",
    "          backstory = \"An weather expert who is expert in providing weather information about any location\",\n",
    "          tools = [Tools.weather_tool],\n",
    "          verbose = True,\n",
    "          allow_delegation = False,\n",
    "      )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s create a task for our weather agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tasks:\n",
    "\t# ... Other tasks\n",
    "    def weatherTask(agent,query):\n",
    "        return Task(\n",
    "            description = dedent(f\"\"\"\n",
    "            Get the location from the user query and find the weather information about that location\n",
    "\n",
    "            Here is the user query:\n",
    "            {query}\n",
    "            \"\"\"),\n",
    "            agent = agent,\n",
    "            expected_output = \"A weather information asked by user\"\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, create a node where we will run this agent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Nodes:\n",
    "\t# ... Other nodes\n",
    "    def weatherNode(self,state):\n",
    "        query = state[\"query\"]\n",
    "        weatherAgent = Agents.weatherAgent()\n",
    "        weatherTask = Tasks.weatherTask(agent=weatherAgent,query=query)\n",
    "        result = weatherTask.execute()\n",
    "        messages = state[\"messages\"]\n",
    "        messages.append(result)\n",
    "        return {\"messages\": messages}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s create entry and reply node as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Nodes:\n",
    "\t# ... Other nodes\n",
    "    def replyNode(self,state):\n",
    "        query = state[\"query\"]\n",
    "        agent = openai_llm.invoke(f\"\"\"\n",
    "            {query}\n",
    "        \"\"\")\n",
    "        messages = state[\"messages\"]\n",
    "        messages.append(agent.content)\n",
    "        return {\"messages\": messages}\n",
    "    def entryNode(self,state):\n",
    "        input = state[\"query\"]\n",
    "        agent = openai_llm.invoke(f\"\"\"\n",
    "        User input\n",
    "        ---\n",
    "        {input}\n",
    "        ---\n",
    "        You have given one user input and you have to perform actions on it based on given instructions\n",
    "\n",
    "        Categorize the user input in below categories\n",
    "        email_query: If user want to generate a reply to given email\n",
    "        weather_query: If user want any weather info about given location\n",
    "        other: If it is any other query\n",
    "\n",
    "        After categorizing your final RESPONSE must be in json format with these properties:\n",
    "        category: category of user input\n",
    "        email: If category is 'email_query' then extract the email body from user input with proper line breaks and add it here else keep it blank\n",
    "        query: If category is 'weather_query' or 'other' then add the user's query here else keep it blank\n",
    "        \"\"\")\n",
    "        response = json.loads(agent.content)\n",
    "        return {'email': response[\"email\"], 'query': response['query'], 'category': response['category']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we have successfully created all the nodes for our workflow!\n",
    "\n",
    "Now let’s define the condition function which will decide the conditional flow for our conditional edge based on the category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def where_to_go(state):\n",
    "  cat = state['category']\n",
    "  print(\"Category: \",cat)\n",
    "  if cat == \"email_query\":\n",
    "    return \"email\"\n",
    "  elif cat == \"weather_query\":\n",
    "    return \"weather\"\n",
    "  else:\n",
    "    return \"reply\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally let’s create the stateful graph and define our nodes in it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.graph import Graph, END, StateGraph\n",
    "workflow = StateGraph(AgentState)\n",
    "node = Nodes()\n",
    "workflow.add_node('entryNode',node.entryNode)\n",
    "workflow.add_node('weatherNode',node.weatherNode)\n",
    "workflow.add_node(\"responder\",node.replyNode)\n",
    "workflow.add_node('emailNode',node.writerNode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s connect these nodes using edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "workflow.add_conditional_edges('entryNode',where_to_go,{\n",
    "    \"email\": \"emailNode\",\n",
    "    \"weather\": \"weatherNode\",\n",
    "    \"reply\": \"responder\"\n",
    "})\n",
    "workflow.add_edge(\"weatherNode\",END)\n",
    "workflow.add_edge(\"responder\",END)\n",
    "workflow.add_edge(\"emailNode\",END)\n",
    "\n",
    "workflow.set_entry_point(\"entryNode\")\n",
    "app = workflow.compile()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now it’s time to test our agent 👀!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "query = \"\"\"\n",
    "Can you reply to this email\n",
    "\n",
    "Hello,\n",
    "Thank you for applying to xyz company\n",
    "can you share me your previous CTC\n",
    "Thanks,\n",
    "HR\n",
    "\"\"\"\n",
    "inputs = {\"query\": query, \"messages\": [query]}\n",
    "result = app.invoke(inputs)\n",
    "print(\"Agent Response:\",result['messages'][-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After running the above code, you will see the query got categorized as “email_query” and then using EmailCrew it will generate the reply for the extracted email which looks like this:\n",
    "\n",
    "```\n",
    "Agent Says: Subject: Re: Application to XYZ Company\n",
    "\n",
    "Dear [HR's Name],\n",
    "\n",
    "Thank you for considering my application for the position at XYZ Company.\n",
    "\n",
    "As per your request, my previous CTC was [mention CTC]. I am open to any negotiation based on the job requirements and the value I can bring to your team at XYZ Company.\n",
    "\n",
    "Thank you once again for the opportunity. I look forward to potentially furthering the application process.\n",
    "\n",
    "Best Regards,\n",
    "[Your Name]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ofc you can make it better with better prompts but I will leave it on you so that you can do experiment with it.\n",
    "\n",
    "You can also try with below queries for different use cases and agent will reply differently.\n",
    "\n",
    "weather_query: \n",
    "```\n",
    "Is there any chance of rain in delhi today?\n",
    "```\n",
    "\n",
    "email_query:\n",
    "```\n",
    "Hey can you generate a reply to this email\n",
    "\n",
    "Hey man,\n",
    "I just saw your portfolio and quite liked it. Can you tell me which languages do you use the most\n",
    "Thanks\n",
    "```\n",
    "\n",
    "other:\n",
    "```\n",
    "Hello how are you?\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}