Chatbot with tools is completed

src/basicchatbot/graph/graph_builder.py

@@ -1,37 +1,82 @@
 import streamlit as st
 from typing import Optional
+from langchain_community.tools.tavily_search import TavilySearchResults
 from langgraph.graph import START, END, StateGraph
-from src.basicchatbot.nodes.basic_chatbot_node import BasicChatBotNode
+from langgraph.prebuilt import tools_condition
+from src.basicchatbot.nodes import BasicChatBotNode, ChatbotWithToolsNode
 from src.basicchatbot.state.state import BasicChatBotState
+from src.basicchatbot.tools import ToolInitializer
 
 
 class GraphBuilder:
+    """Builds different chatbot workflows based on the selected use case."""
+
     def __init__(self, model):
         self.llm = model
         self.workflow = StateGraph(BasicChatBotState)
-    
-    def basic_chatbot_build_graph(self):
-
-        self.workflow.add_node("chatbot", BasicChatBotNode(model=self.llm).node)
-        
-        self.workflow.add_edge(START, "chatbot")
-        self.workflow.add_edge("chatbot", END)
-    
-    def chatbot_with_tools_build_graph(self):
-        """Builds a graph for a chatbot with external tool integrations (to be implemented)."""
-        pass  # Placeholder for future implementation
+        self.tool_initializer = ToolInitializer()
+
+    def _basic_chatbot_build_graph(self) -> None:
+        """Builds a simple chatbot graph without external tools."""
+        try:
+            self.workflow.add_node("chatbot", BasicChatBotNode(model=self.llm).node)
+            self.workflow.add_edge(START, "chatbot")
+            self.workflow.add_edge("chatbot", END)
+        except Exception as e:
+            st.error(f"Error in Basic Chatbot Graph: {str(e)}")
+
+    def _chatbot_with_tools_build_graph(self) -> None:
+        """Builds a chatbot graph with external tool integrations."""
+        try:
+            self.tool_initializer.tool_manager.add_tools(  # add comma seperated tools
+                TavilySearchResults(max_results=5)
+            )
+            tools = self.tool_initializer.get_all_tools()
+            if not tools:
+                st.warning("No tools available. The chatbot may not function as expected.")
+            
+            tool_node = self.tool_initializer.create_tool_node()
+
+            self.workflow.add_node("chatbot", ChatbotWithToolsNode(model=self.llm, tools=tools).node)
+            self.workflow.add_node("tools", tool_node)
+
+            self.workflow.add_edge(START, "chatbot")
+            self.workflow.add_conditional_edges(
+                "chatbot",
+                tools_condition,
+                {
+                    "tools": "tools",
+                    "__end__": END
+                }
+            )
+            self.workflow.add_edge("tools", "chatbot")
+        except Exception as e:
+            st.error(f"Error in Chatbot with Tools Graph: {str(e)}")
 
     def setup_graph(self, usecase: str) -> Optional[StateGraph]:
+        """
+        Sets up the appropriate chatbot graph based on the selected use case.
+
+        Args:
+            usecase (str): The chatbot type ("Basic Chatbot" or "Chatbot with Tools").
 
+        Returns:
+            Optional[StateGraph]: The compiled chatbot workflow or None if an error occurs.
+        """
         usecase_mapping = {
-            "Basic Chatbot": self.basic_chatbot_build_graph,
-            "Chatbot with Tools": self.chatbot_with_tools_build_graph,
+            "Basic Chatbot": self._basic_chatbot_build_graph,
+            "Chatbot with Tools": self._chatbot_with_tools_build_graph,
         }
 
         build_graph = usecase_mapping.get(usecase)
 
         if build_graph:
-            build_graph()
-            return self.workflow.compile()
+            try:
+                build_graph()
+                return self.workflow.compile()
+            except Exception as e:
+                st.error(f"Error compiling the graph: {str(e)}")
+                return None
         else:
             st.error(f"Invalid use case: {usecase}. Choose from {list(usecase_mapping.keys())}.")
+            return None

src/basicchatbot/main.py

@@ -34,6 +34,9 @@ def load_basic_chatbot():
             try:
                 graph_builder = GraphBuilder(model=llm)
                 graph = graph_builder.setup_graph(usecase)
+                if graph is None:
+                    st.error("Error: Graph setup failed.")
+                    return
                 
                 DisplayResultStreamlit(
                     usecase=usecase,

src/basicchatbot/tools/__init__.py

@@ -1 +1,3 @@
-from src.basicchatbot.tools.tools import ToolManager
+from src.basicchatbot.tools.tool_manager import ToolManager
+from src.basicchatbot.tools.tools_initializer import ToolInitializer
+

src/basicchatbot/tools/tools_initializer.py

@@ -0,0 +1,30 @@
+from typing import List, Any
+from langgraph.prebuilt import ToolNode
+from src.basicchatbot.tools import ToolManager
+
+
+class ToolInitializer:
+    """Initializes and manages multiple tools using ToolManager."""
+
+    def __init__(self):
+        """Initialize ToolInitializer with a ToolManager instance."""
+        self.tool_manager = ToolManager()
+
+    def get_all_tools(self) -> List[Any]:
+        """
+        Retrieve all tools currently added to the manager.
+
+        Returns:
+            List[Any]: A list of all registered tools.
+        """
+        return self.tool_manager.get_tools()
+
+    def create_tool_node(self) -> ToolNode:
+        """
+        Create a ToolNode with all registered tools.
+
+        Returns:
+            ToolNode: A LangGraph ToolNode containing all active tools.
+        """
+        return self.tool_manager.create_tool_node()
+

src/basicchatbot/ui/streamlitui/display_result.py

@@ -95,7 +95,7 @@ class DisplayResultStreamlit:
     def display_result_on_ui(self) -> None:
         usecase_handlers = {
             "Basic Chatbot": self._handle_basic_chatbot,
-            "Chatbot with Tool": self._handle_chatbot_with_tool,
+            "Chatbot with Tools": self._handle_chatbot_with_tool,
         }
 
         handler = usecase_handlers.get(self.usecase)

src/basicchatbot/ui/streamlitui/loadui.py

@@ -88,7 +88,7 @@ class StreamlitUILoader:
             usecase_options = self.config.get_usecase_options()
             self.user_input['selected_usecase'] = st.selectbox(label="Select Usecase",options=usecase_options)
 
-            if self.user_input['selected_usecase'] == "Chatbot with Tool":
+            if self.user_input['selected_usecase'] == "Chatbot with Tools":
                 self._setup_tavily_configuration()
 
         return self.user_input

src/basicchatbot/ui/uiconfigfile.ini

@@ -1,6 +1,6 @@
 [DEFAULT]
 PAGE_TITLE = Baisc Chatbot with LangGraph
 LLM_OPTIONS = Groq, OpenAI
-USECASE_OPTIONS = Basic Chatbot, Chatbot with Tool
+USECASE_OPTIONS = Basic Chatbot, Chatbot with Tools
 GROQ_MODEL_OPTIONS = qwen-2.5-32b, qwen-2.5-coder-32, deepseek-r1-distill-qwen-32b, gemma2-9b-it, llama3-8b-8192, llama3-70b-8192
 OPENAI_MODEL_OPTIONS = gpt-3.5-turbo-0125,gpt-4o-mini-2024-07-18,gpt-4o-2024-08-06,o3-mini-2025-01-31, o1-mini-2024-09-12