chatbot wiht tools

Agentic_chatbot.ipynb

@@ -1,33 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dc1df7f3",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.13.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

src/langgraph_agentic_ai/UI/streamlitui/display_result.py

@@ -22,4 +22,22 @@ 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 WebSearch":
+             # 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/langgraph_agentic_ai/UI/streamlitui/loadui.py

@@ -34,4 +34,11 @@ class LoadStreamlitUI:
             ## USecase selection
             self.user_controls["selected_usecase"]=st.selectbox("Select Usecases",usecase_options)
 
+            if self.user_controls["selected_usecase"] == "Chatbot with WebSearch":
+                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")
+
+                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")
+
+
         return self.user_controls

src/langgraph_agentic_ai/UI/streamlitui/uiconfigfile.ini

@@ -1,5 +1,5 @@
 [DEFAULT]
 PAGE_TITLE= LangGraph: Build stateful Agentic Ai graph
 LLM_OPTIONS= Groq
-USECASE_OPTIONS= Basic Chatbot, Chatbot with Tool, AI News, Blog Generator
+USECASE_OPTIONS= Basic Chatbot, Chatbot with WebSearch, AI News, Blog Generator
 GROQ_MODEL_OPTIONS= deepseek-r1-distill-llama-70b, gemma2-9b-it, llama-3.1-8b-instant

src/langgraph_agentic_ai/graph/graph_builder.py

@@ -1,7 +1,13 @@
 from langgraph.graph import StateGraph
+from langgraph.prebuilt import tools_condition
 from src.langgraph_agentic_ai.state.state import State
 from langgraph.graph import START,END
 from src.langgraph_agentic_ai.nodes.basic_chatbot_node import BasicChatbotNode
+from src.langgraph_agentic_ai.tools.search_tool import get_tools,create_tool_node
+from langgraph.prebuilt import tools_condition,ToolNode
+from src.langgraph_agentic_ai.nodes.chatbot_with_tool_node import chatbotwithToolNode
+
+
 
 class GraphBuilder:
     def __init__(self,model):
@@ -26,6 +32,33 @@ 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 the LLM
+        llm=self.llm
+
+        ## Define the 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)
+        
+        self.graph_builder.add_edge(START,"chatbot")
+        self.graph_builder.add_conditional_edges("chatbot",tools_condition)
+        self.graph_builder.add_edge("tools","chatbot")
+        self.graph_builder.add_edge("chatbot",END)
 
     def setup_graph(self,usecase:str):
         """
@@ -34,6 +67,8 @@ class GraphBuilder:
         """
         if usecase == "Basic Chatbot":
             self.basic_chatbot_build_graph()
+        if usecase == "Chatbot with WebSearch":
+            self.chatbot_with_tools_build_graph()
         
         return self.graph_builder.compile()
 

src/langgraph_agentic_ai/nodes/chatbot_with_tool_node.py

@@ -0,0 +1,37 @@
+from src.langgraph_agentic_ai.state.state import State
+
+class chatbotwithToolNode:
+    """
+    Chatbot logic enhanced with tool integration
+    """
+
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self,state: State)->dict:
+        """
+        Process the input state and generate a response with tool integration
+        """
+        user_input= state["messages"][-1] if state ["messages"] else ""
+        llm_response = self.llm.invoke([{'role':"user","content":user_input}])
+
+        tools_response = f"Tool integration for '{user_input}"
+
+        return {"messages":[llm_response,tools_response]}
+
+
+    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/langgraph_agentic_ai/tools/search_tool.py

@@ -0,0 +1,16 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langgraph.prebuilt import ToolNode
+
+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):
+    """
+    create and returns a tool node for the graph
+    """
+    return ToolNode(tools=tools)