Chatbot with Tool Integration

README.md

@@ -9,7 +9,7 @@ app_file: app.py
 pinned: false
 ---
 
-# Project Setup Steps
+# Project Setup
 
 ## Steps
 
@@ -111,8 +111,59 @@ from src.langgraphagenticai.ui.streamlitui.display_result import DisplayResultSt
 ```sh
 streamlit run app.py
 ```
+# 🚀 CI/CD Setup: GitHub to Hugging Face  
 
+## 🔹 1. Set Up CI/CD Between GitHub and Hugging Face  
+- **Create** a new Space on Hugging Face.  
+- A **unique URL** will be generated for your Space.  
+- Open **`main.yml`** and update the **last line**:  
+  - Replace it with your Hugging Face Space **unique URL** (it will include `$HF_TOKEN`).  
+- **Update the README**:  
+  - The **first section** of the README should contain the **Streamlit configuration**.  
 
+## 🔹 2. Deploy on Streamlit  
+- **Go to the Streamlit website** and add your GitHub repo and branch details.  
+- Deployment example:  
+  👉 [LangGraph Streamlit App](https://langgraphe2e-4cg4bxcc3ysrhwrmregluy.streamlit.app/)  
+
+---
+
+Your CI/CD pipeline should now be set up for seamless deployment! 🚀✨  
+
+---
+# Chatbot with Tool Integration  
+
+## 📌 Steps to Implement  
+
+### 🔹 1. Add a Search Tool  
+- Navigate to the `TOOLS` folder.  
+- **Create** a new file: `search_tool.py`.  
+- **Add Tavily** as a tool inside this file.  
+
+### 🔹 2. Create a Chatbot with Tool Node  
+- Navigate to the `NODES` folder.  
+- **Create** a new file: `Chatbot_with_tool_node.py`.  
+- Implement chatbot logic with tool integration inside this file.  
+
+### 🔹 3. Modify Graph Builder  
+- Open `graph_builder.py`.  
+- **Edit** the file to include tool functionality.  
+
+### 🔹 4. Update the UI  
+- Modify the following UI components:  
+  - `Load_streamlit_ui.py`  
+  - `uiconfig.ini`  
+  - `display_results.py`  
+
+### 🔹 5. Run the Application  
+To start the chatbot, run the following command:  
+streamlit run app.py
+
+🚀 Now your chatbot with tool integration should be live!
+
+## Ouput Screenshots 
+Streamlit UI interface showcasing chatbot utilizing tools
+![alt text](image.png)
 
 
 

src/langgraphagenticai/graph/graph_builder.py

@@ -3,8 +3,8 @@ 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_Tool_node import ChatbotWithToolNode
+from src.langgraphagenticai.tools.search_tool import get_tools,create_tool_node
 
 
 class GraphBuilder:
@@ -25,15 +25,52 @@ 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_Tool_node.py

@@ -0,0 +1,50 @@
+from src.langgraphagenticai.state.state import State
+
+#State is like a memory that stores chat messages
+#creates a chatbot that can Take user messages as input, Use an AI model (llm) to generate responses and Integrate tools to improve its responses
+
+#This class manages a chatbot that can use tools
+class ChatbotWithToolNode:
+    """
+    Chatbot logic enhanced with tool integration.
+    """
+ #constructor method that takes self (the instance of the class) and model (a parameter)
+    def __init__(self,model):
+        self.llm = model # Attribute (self.llm) stores the parameter (model)
+
+  #This method processes user input and generates responses. Methods always have self as the first parameter
+    def process(self, state: State) -> dict: #-> dict is a return type hint and state:State is also a type hint, expects state to be of type State
+        """
+        Processes the input state and generates a response with tool integration.
+        """
+        user_input = state["messages"][-1] if state["messages"] else "" #gets the latest user message from state else nothing
+        llm_response = self.llm.invoke([{"role": "user", "content": user_input}]) #AI model (self.llm) generates a response based on user input
+
+        # Simulate tool-specific logic
+        tools_response = f"Tool integration for: '{user_input}'"
+
+        return {"messages": [llm_response, tools_response]}
+    
+    #This function adds tools to the chatbot.
+    def create_chatbot(self, tools):
+        """
+        Returns a chatbot node function.
+        """
+        llm_with_tools = self.llm.bind_tools(tools) #connects the chatbot to external tools
+        
+        #function that processes messages
+        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/state/state.py

@@ -4,8 +4,8 @@ from langgraph.graph.message import add_messages
 from typing import TypedDict, Annotated, List
 from langchain_core.messages import HumanMessage, AIMessage
 
-class State(TypedDict):
+class State(TypedDict): #State is a class that inherits from TypedDict, State will act like a dictionary but with fixed keys and expected data types
     """
     Represents the structure of the state used in the graph.
     """
-    messages: Annotated[list, add_messages]
+    messages: Annotated[list, add_messages] # messages is a key inside State dictionary and Annotated → A way to add extra metadata to a type hint.

src/langgraphagenticai/tools/search_tool.py

@@ -0,0 +1,18 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langgraph.prebuilt import ToolNode
+
+#insert any number of tools created into this fuction 
+def get_tools():
+    """
+    Return the list of tools to be used in the chatbot
+    """
+    tools=[TavilySearchResults(max_results=2)]
+    return tools
+
+#above tools in the form of node
+def create_tool_node(tools):
+    """
+    creates and returns a tool node for the graph
+    """
+    return ToolNode(tools=tools) #ToolNode is a ready-made building block that helps an AI agent use external tools
+#assigning the input argument tools to the tools parameter inside ToolNode

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -1,5 +1,5 @@
 import streamlit as st
-from langchain_core.messages import HumanMessage,AIMessage
+from langchain_core.messages import HumanMessage,AIMessage,ToolMessage
 import json
 
 
@@ -21,4 +21,21 @@ 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

@@ -56,9 +56,16 @@ class LoadStreamlitUI:
             # Use case selection
             self.user_controls["selected_usecase"] = st.selectbox("Select Usecases", usecase_options)
             
+            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()
             
             
-        
         return self.user_controls

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