seperated for display results

src/langgraphagenticai/main.py

@@ -1,61 +1,69 @@
+from src.langgraphagenticai.ui.streamlitui.display_result import DisplayResultStreamlit
 from src.langgraphagenticai.LLMS.groqllm import GroqLLM
 from src.langgraphagenticai.graph.graph_builder import GraphBuilder
 from src.langgraphagenticai.ui.streamlitui.loadui import LoadStreamlitUI
 
 import streamlit as st
-from langchain_core.messages import HumanMessage,AIMessage,ToolMessage
 
 
 # MAIN Function START
 def load_langgraph_agenticai_app():
-    
-    # load ui
-    ui = LoadStreamlitUI()
-    user_input = ui.load_streamlit_ui()
+    """
+    Loads and runs the LangGraph AgenticAI application with Streamlit UI.
 
-    # Text input for user message
-    user_message = st.chat_input("Enter your message:")
-    if user_message:
-        # Configure LLM
-        obj_llm_config = GroqLLM(user_controls_input=user_input)
-        model = obj_llm_config.get_llm_model()
+    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.
+    """
+    try:
+        # 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
+        user_message = st.chat_input("Enter your message:")
+        if user_message:
+            try:
+                # Configure LLM
+                obj_llm_config = GroqLLM(user_controls_input=user_input)
+                model = obj_llm_config.get_llm_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 = GraphBuilder(model)
+                
+                try:
+                    graph = graph_builder.setup_graph(usecase)
+                except Exception as e:
+                    st.error(f"Error: Graph setup failed - {e}")
+                    return
+
+                # Display output in UI
+                try:
+                    DisplayResultStreamlit(usecase,graph,user_message).display_result_on_ui()
+                except Exception as e:
+                    st.error(f"Error: Failed to display results on UI - {e}")
+
+            except Exception as e:
+                st.error(f"Error: LLM configuration failed - {e}")
+
+    except Exception as e:
+        st.error(f"Unexpected error occurred: {e}")
 
-        # Initialize and set up the graph based on use case
-        usecase = user_input['selected_usecase']
-        graph_builder = GraphBuilder(model)
-        graph = graph_builder.setup_graph(usecase)
         
-        # Display output in UI
-        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)
         
-        # display graph
-        if graph:
-            st.write('state graph - workflow')
-            st.image(graph.get_graph(xray=True).draw_mermaid_png())
                         
        
                 

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -0,0 +1,44 @@
+import streamlit as st
+from langchain_core.messages import HumanMessage,AIMessage,ToolMessage
+
+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)
+            
+            # display graph
+            if graph:
+                st.write('state graph - workflow')
+                st.image(graph.get_graph(xray=True).draw_mermaid_png())