added tavily search tool node

src/langgraphagenticai/graph/graph_builder.py

@@ -3,7 +3,10 @@ from langgraph.prebuilt import tools_condition,ToolNode
 from langchain_core.prompts import ChatPromptTemplate
 from src.langgraphagenticai.state.state import State
 from src.langgraphagenticai.nodes.basic_chatbot_node import BasicChatbotNode
+from src.langgraphagenticai.nodes.chatbot_with_toolnode import ChatbotWithToolNode
+from src.langgraphagenticai.tools.search_tool import get_tools,create_tool_node
 
+## adding the created tool node and whenever user selects the chatbot with tool it will be called 
 
 
 
@@ -25,12 +28,46 @@ class GraphBuilder:
         self.graph_builder.add_edge(START,"chatbot")
         self.graph_builder.add_edge("chatbot",END)
 
+    def chatbot_with_tools_build_graph(self):
+        """
+        Builds an advanced chatbot graph with tool integration.
+        This method creates a chatbot graph that includes both a chatbot node 
+        and a tool node. It defines tools, initializes the chatbot with tool 
+        capabilities, and sets up conditional and direct edges between nodes. 
+        The chatbot node is set as the entry point.
+        """
+        ## Define the tool and tool node
+
+        tools=get_tools()
+        tool_node=create_tool_node(tools)
+
+        ##Define LLM
+        llm = self.llm
+
+        # Define chatbot node
+        obj_chatbot_with_node = ChatbotWithToolNode(llm)
+        chatbot_node = obj_chatbot_with_node.create_chatbot(tools)
+
+        # Add nodes
+        self.graph_builder.add_node("chatbot", chatbot_node)
+        self.graph_builder.add_node("tools", tool_node)
+
+        # Define conditional and direct edges
+        self.graph_builder.add_edge(START,"chatbot")
+        self.graph_builder.add_conditional_edges("chatbot", tools_condition)
+        self.graph_builder.add_edge("tools","chatbot")
+
+
     def setup_graph(self, usecase: str):
         """
         Sets up the graph for the selected use case.
         """
         if usecase == "Basic Chatbot":
             self.basic_chatbot_build_graph()
+
+        if usecase == "Chatbot with Tool":
+            self.chatbot_with_tools_build_graph()
+            
         return self.graph_builder.compile()
 
 

src/langgraphagenticai/nodes/chatbot_with_toolnode.py

@@ -0,0 +1,52 @@
+from src.langgraphagenticai.state.state import State
+
+## added a tool node, for each tool u create just add the tool functionality in tools folder file
+
+class ChatbotWithToolNode:
+    """
+    Chatbot logic enhanced with tool integration.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates a response with tool integration.
+        """
+        user_input = state["messages"][-1] if state["messages"] else ""
+        llm_response = self.llm.invoke([{"role": "user", "content": user_input}])
+
+        # Simulate tool-specific logic
+        tools_response = f"Tool integration for: '{user_input}'"
+
+        return {"messages": [llm_response, tools_response]}
+    
+    # def chatbot_node(state: State,llm_with_tools):
+    #     """
+    #     Chatbot logic for processing the input state and returning a response.
+    #     """
+    #     return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+    # def create_chatbot(self,tools):
+    #     """
+    #     Returns a chatbot node function.
+    #     """
+    #     llm_with_tools = self.llm.bind_tools(tools)
+
+    #     return self.chatbot_node(State,llm_with_tools)
+
+
+    def create_chatbot(self, tools):
+        """
+        Returns a chatbot node function.
+        """
+        llm_with_tools = self.llm.bind_tools(tools)
+
+        def chatbot_node(state: State):
+            """
+            Chatbot logic for processing the input state and returning a response.
+            """
+            return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+        return chatbot_node
+ 

src/langgraphagenticai/tools/search_tool.py

@@ -0,0 +1,18 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langgraph.prebuilt import ToolNode
+
+
+## create a new search tool if u want to add more tools u can add them in tools [] list
+
+def get_tools():
+    """
+    Return the list of tools to be used in the chatbot
+    """
+    tools=[TavilySearchResults(max_results=2)]
+    return tools
+
+def create_tool_node(tools):
+    """
+    creates and returns a tool node for the graph
+    """
+    return ToolNode(tools=tools)

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -1,8 +1,10 @@
 import streamlit as st
-from langchain_core.messages import HumanMessage,AIMessage
+from langchain_core.messages import HumanMessage,AIMessage,ToolMessage
 import json
 
 
+## display change when chatbot with tools is added
+
 class DisplayResultStreamlit:
     def __init__(self,usecase,graph,user_message):
         self.usecase= usecase
@@ -21,4 +23,24 @@ class DisplayResultStreamlit:
                         with st.chat_message("user"):
                             st.write(user_message)
                         with st.chat_message("assistant"):
-                            st.write(value["messages"].content)
+                            st.write(value["messages"].content)
+
+        elif usecase=="Chatbot with Tool":
+            # Prepare state and invoke the graph
+            initial_state = {"messages": [user_message]}
+            res = graph.invoke(initial_state)
+            for message in res['messages']:
+                if type(message) == HumanMessage:
+                    with st.chat_message("user"):
+                        st.write(message.content)
+                elif type(message)==ToolMessage:
+                    with st.chat_message("ai"):
+                        st.write("Tool Call Start")
+                        st.write(message.content)
+                        st.write("Tool Call End")
+                elif type(message)==AIMessage and message.content:
+                    with st.chat_message("assistant"):
+                        st.write(message.content)
+
+        
+    

src/langgraphagenticai/ui/streamlitui/loadui.py

@@ -5,6 +5,7 @@ from datetime import date
 from langchain_core.messages import AIMessage,HumanMessage
 from src.langgraphagenticai.ui.uiconfigfile import Config
 
+## added when chatbot with tools is added
 
 class LoadStreamlitUI:
     def __init__(self):
@@ -56,6 +57,17 @@ class LoadStreamlitUI:
             # Use case selection
             self.user_controls["selected_usecase"] = st.selectbox("Select Usecases", usecase_options)
             
+            ## added when chatbot with tools is added
+
+            if self.user_controls["selected_usecase"] =="Chatbot with Tool":
+                # API key input
+                os.environ["TAVILY_API_KEY"] = self.user_controls["TAVILY_API_KEY"] = st.session_state["TAVILY_API_KEY"] = st.text_input("TAVILY API KEY",
+                                                                                                    type="password")
+                # Validate API key
+                if not self.user_controls["TAVILY_API_KEY"]:
+                    st.warning("⚠️ Please enter your TAVILY_API_KEY key to proceed. Don't have? refer : https://app.tavily.com/home")
+            
+
             if "state" not in st.session_state:
                 st.session_state.state = self.initialize_session()
             

src/langgraphagenticai/ui/uiconfigfile.ini

@@ -1,6 +1,6 @@
 [DEFAULT]
 PAGE_TITLE = LangGraph: Build Stateful Agentic AI graph
 LLM_OPTIONS = Groq
-USECASE_OPTIONS = Basic Chatbot
+USECASE_OPTIONS = Basic Chatbot, Chatbot with Tool
 GROQ_MODEL_OPTIONS = mixtral-8x7b-32768, llama3-8b-8192, llama3-70b-8192, gemma-7b-i