chabot graph build & tested

app.py

@@ -0,0 +1,5 @@
+import os 
+from src.main import load_langgraph_agenticai_app
+
+if __name__=="__main__":
+    load_langgraph_agenticai_app()

src/graph/graph_builder.py

@@ -0,0 +1,65 @@
+import os 
+
+# Add the src directory to the Python path
+import sys
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from langgraph.graph import StateGraph, START,END
+from langgraph.prebuilt import tools_condition,ToolNode
+from langchain_core.prompts import ChatPromptTemplate
+from src.state.state import graphstate
+from src.nodes.basic_chatbot_nodes import BasicChatbotNodes
+from src.nodes.chabot_with_tool_nodes import ChatbotWithToolNodes
+from src.tools.search_tool import get_tools, create_tool_node
+
+
+class GraphBuilder:
+    def __init__(self, model):
+        self.model = model
+        self.graph_builder =StateGraph(graphstate)
+    
+    def basic_chabot_build(self):
+        """
+        Builds a basic chatbot graph using LangGraph.
+        This method initializes a chatbot node using the `BasicChatbotNode` class 
+        and integrates it into the graph. The chatbot node is set as both the 
+        entry and exit point of the graph.
+        """
+        self.basic_chabot_node = BasicChatbotNodes(self.model)
+        self.graph_builder.add_node("chatbot", self.basic_chabot_node.process)
+        self.graph_builder.add_edge(START, "chatbot")
+        self.graph_builder.add_edge("chatbot", END)
+       
+    def chatbot_with_tool_build(self):
+        """
+        Builds a chatbot graph with a tool node using LangGraph.
+        This method initializes a chatbot node using the `ChatbotWithToolNodes`"
+        """
+        tools:list= get_tools()
+        tool_node = create_tool_node(tools)
+        llm= self.model
+
+        # Define chatbot node
+        obj_chatbot_with_node = ChatbotWithToolNodes(llm)
+        chatbot_node = obj_chatbot_with_node.create_chatbot(tools)
+
+        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_chabot_build()
+
+        if usecase == "Chatbot with Tool":
+            self.chatbot_with_tool_build()
+
+        return self.graph_builder.compile()
+

src/llms/groq_llms.py

@@ -12,16 +12,16 @@ class GroqLLMS:
         """
         self.user_controls= user_controls_input
 
-        def get_groq_model(self):
-            try:
-                api_key= self.user_controls["GROQ_API_KEY"]
-                model_name= self.user_controls["selected_model"]
-                if not api_key and os.environ["GROQ_API_KEY"]:
-                    st.error("Please enter your GROQ API key to proceed. Don't have? refer : https://console.groq.com/keys ", icon="🚨")
-                llm = ChatGroq(model=model_name, api_key= api_key)
-            except Exception as e:
-                st.error("Error in fetching the model " +str(e))
-            return llm
+    def get_groq_model(self):
+        try:
+            api_key= self.user_controls["GROQ_API_KEY"]
+            model_name= self.user_controls["selected_model"]
+            if not api_key and os.environ["GROQ_API_KEY"]:
+                st.error("Please enter your GROQ API key to proceed. Don't have? refer : https://console.groq.com/keys ", icon="🚨")
+            llm = ChatGroq(model=model_name, api_key= api_key)
+        except Exception as e:
+            st.error("Error in fetching the model " +str(e))
+        return llm
                    
 
        

src/main.py

@@ -0,0 +1,68 @@
+import streamlit as st
+import json
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+from src.user_interface.streamlitui.loadui import LoadStreamlitUI
+from src.user_interface.streamlitui.display_result import DisplayResultStreamlit
+from src.llms.groq_llms import GroqLLMS
+from src.graph.graph_builder import GraphBuilder
+
+
+# MAIN Function START
+def load_langgraph_agenticai_app():
+    """
+    Loads and runs the LangGraph AgenticAI application with Streamlit UI.
+    This function initializes the UI, handles user input, configures the LLM model,
+    sets up the graph based on the selected use case, and displays the output while 
+    implementing exception handling for robustness.
+    """
+   
+    # Load UI
+    ui = LoadStreamlitUI()
+    user_input = ui.load_streamlit_ui()
+
+    if not user_input:
+        st.error("Error: Failed to load user input from the UI.")
+        return
+
+    # Text input for user message
+    if st.session_state.IsFetchButtonClicked:
+        user_message = st.session_state.timeframe 
+    else :
+        user_message = st.chat_input("Enter your message:")
+
+    if user_message:
+            try:
+                # Configure LLM
+                obj_llm_config = GroqLLMS(user_controls_input=user_input)
+                model = obj_llm_config.get_groq_model()
+                
+                if not model:
+                    st.error("Error: LLM model could not be initialized.")
+                    return
+
+                # Initialize and set up the graph based on use case
+                usecase = user_input.get('selected_usecase')
+                if not usecase:
+                    st.error("Error: No use case selected.")
+                    return
+                
+
+                ### Graph Builder
+                graph_builder=GraphBuilder(model)
+                try:
+                    graph = graph_builder.setup_graph(usecase)
+                    DisplayResultStreamlit(usecase,graph,user_message).display_result_on_ui()
+                except Exception as e:
+                    st.error(f"Error: Graph setup failed - {e}")
+                    return
+                
+
+            except Exception as e:
+                 raise ValueError(f"Error Occurred with Exception : {e}")
+            
+
+

src/nodes/basic_chatbot_nodes.py

@@ -9,7 +9,7 @@ class BasicChatbotNodes:
     def __init__(self, model):
         self.llm = model
     
-    def peocess(self, state: graphstate):
+    def process(self, state: graphstate):
         return {"messages":
                 self.llm.invoke(state["messages"])}
       

src/user_interface/streamlitui/display_result.py

@@ -0,0 +1,42 @@
+import streamlit as st
+from langchain_core.messages import HumanMessage,AIMessage,ToolMessage
+import json
+
+
+class DisplayResultStreamlit:
+    def __init__(self,usecase,graph,user_message):
+        self.usecase= usecase
+        self.graph = graph
+        self.user_message = user_message
+
+    def display_result_on_ui(self):
+        usecase= self.usecase
+        graph = self.graph
+        user_message = self.user_message
+        if usecase =="Basic Chatbot":
+                for event in graph.stream({'messages':("user",user_message)}):
+                    print(event.values())
+                    for value in event.values():
+                        print(value['messages'])
+                        with st.chat_message("user"):
+                            st.write(user_message)
+                        with st.chat_message("assistant"):
+                            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/user_interface/streamlitui/loadui.py

@@ -57,7 +57,7 @@ class LoadStreamlitUI:
             if self.user_controls["selected_usecase"] == 'Chatbot with Tool':
 
                 #ask for Tavily API key
-                self.user_controls["TAVILY_API_KEY"] = st.session_state["TAVILY_API_KEY"] = st.text_input("Enter your Tavily API Key", type="password")
+                os.environ["TAVILY_API_KEY"] = self.user_controls["TAVILY_API_KEY"]= st.session_state["TAVILY_API_KEY"] = st.text_input("Enter your Tavily API Key", type="password")
                 if not self.user_controls["TAVILY_API_KEY"]:
                     st.warning("⚠️ Please enter your TAVILTY API key to proceed. Don't have? refer : https://tavily.com/")