adding all parameters to run the UI

requirements.txt

@@ -1,7 +1,6 @@
 langchain
 openai
 langGraph
-langGraph-community
 langchain-community
 langchain-groq
 langchain-openai

src/langgraph/UI/streamlit/displayresult.py

@@ -0,0 +1,24 @@
+import streamlit as st
+from langchain_core.messages import HumanMessage,AIMessage
+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)

src/langgraph/UI/streamlit/loadui.py

@@ -10,3 +10,62 @@ class LoadStreamlitUI:
     def __init__(self):
         self.config = Config()
         self.user_config = {}
+
+    def initialize_state(self):
+        return {
+            "timeframe": "",
+            "current_step": "requirements",
+            "requirements": "",
+            "user_stories": "",
+            "IsFetchButtonClicked": False,
+            "Is_SDLC": False
+        }
+    
+    # def render_requirements(self):
+    #     st.markdown("## Requirements Submission")
+    #     st.session_state.state["requirements"] = st.text_area("Enter Your Requirements", height=100, key="get_requirements")
+
+    #     if st.button("Submit Requirements", key="submit_requirements"):
+    #         st.session_state["current_step"] = "generate_user_stories"
+    #         st.session_state.IsSLDC = True
+
+
+    def load_ui(self):
+        st.set_page_config(
+            page_title="👁" + self.config.get_page_title(),
+            #page_icon=self.config.get_page_icon(),
+            layout="wide"
+        )
+        st.header(self.config.get_page_title())
+        st.markdown("---")
+        st.session_state.timeframe = ''
+        st.session_state.IsFetchButtonClicked = False
+        st.session_state.Is_SDLC = False
+
+        with st.sidebar:
+            #Getting sidebar options from the config file
+            LLM_OPTIONS = self.config.get_llm_options()
+            USE_CASE_OPTIONS = self.config.get_usecase_options()
+
+            #Creating a dropdown for the LLM options
+            st.session_state.selected_llm = st.selectbox("Select LLM", LLM_OPTIONS)
+
+            if st.session_state.selected_llm == "Groq":
+                model = self.config.get_groq_model()
+                st.session_state.selected_model = st.selectbox("Select Model", model)
+                st.session_state.selected_model_api_key = st.text_input("Enter API Key", type="password")
+
+                #validating the API key
+                if not st.session_state.selected_model_api_key:
+                    st.error("Please enter the correct API key. refer :  https://console.groq.com/keys")
+
+            #Creating a dropdown for the use case options
+            st.session_state.selected_usecase = st.selectbox("Select Use Case", USE_CASE_OPTIONS)
+
+            if "state" not in st.session_state:
+                st.session_state.state = self.initialize_state()
+            #self.render_requirements()
+
+        return self.user_controls
+
+            

src/langgraph/graph/graph_builder.py

@@ -0,0 +1,38 @@
+from langgraph.graph import StateGraph, START,END, MessagesState
+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
+
+
+
+
+class GraphBuilder:
+
+    def __init__(self,model):
+        self.llm=model
+        self.graph_builder=StateGraph(State)
+
+    def basic_chatbot_build_graph(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_chatbot_node=BasicChatbotNode(self.llm)
+        self.graph_builder.add_node("chatbot",self.basic_chatbot_node.process)
+        self.graph_builder.add_edge(START,"chatbot")
+        self.graph_builder.add_edge("chatbot",END)
+
+    def setup_graph(self, usecase: str):
+        """
+        Sets up the graph for the selected use case.
+        """
+        if usecase == "Basic Chatbot":
+            self.basic_chatbot_build_graph()
+        return self.graph_builder.compile()
+
+
+
+    

src/langgraph/llm/groqllm.py

@@ -10,3 +10,13 @@ class GroqLLM:
         try:
             groq_api_key = self.user_controls_input["groq_api_key"]
             selected_groq_model = self.user_controls_input["selected_groq_models"]
+
+            if not groq_api_key:
+                st.error("Please enter the Groq API Key")
+            
+            llm = ChatGroq(api_key=groq_api_key, model=selected_groq_model)
+
+        except Exception as e:
+            st.error(f"Error in getting the Groq API Key: {e}", e)
+        
+        return llm

src/langgraph/main.py

@@ -0,0 +1,58 @@
+import streamlit as st
+import json
+from src.langgraph.UI.streamlit.loadui import LoadStreamlitUI
+from src.langgraph.llm.groqllm import GroqLLM
+from src.langgraph.graph.graph_builder import GraphBuilder
+from src.langgraph.UI.streamlit.displayresult import DisplayResultStreamlit
+
+
+def __main__():
+    """
+    
+    Loads and runs the LangGranph Agentic AI POC application.
+
+    """
+
+    #load the UI
+    ui = LoadStreamlitUI()
+    user_input = ui.load_ui()
+
+    if not user_input:
+        st.error("Please enter the requirements and click on the button to generate the SDLC")
+        return
+    
+    #Test input for user message state
+    if st.session_state.IsFetchButtonClicked:
+        user_message = st.session_state.state.timeframe
+    else:
+        user_message = st.chat_input("Enter your message here...")
+
+    #Initialize the LLM
+    if user_message:
+        try:
+            llm = GroqLLM(user_controls_input=user_input)
+            model = llm.get_llm_model()
+
+            if not model:
+                st.error("Failed to initialize the LLM model")
+                return
+            
+            #select use-case
+            use_case = user_input.get("selected_use_case")
+            if not use_case:
+                st.error("No Use Case Selected")
+                return
+            
+            #Graph Builder
+            graph_builder = GraphBuilder(llm=model, use_case=use_case)
+            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/langgraph/node/basic_chatbot.py

@@ -0,0 +1,14 @@
+from src.langgraph.state.state import State
+
+class BasicChatbotNode:
+    """
+    Basic chatbot logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates a chatbot response.
+        """
+        return {"messages":self.llm.invoke(state['messages'])}

src/langgraph/state/state.py

@@ -0,0 +1,11 @@
+from typing import Annotated, Literal, Optional
+from typing_extensions import TypedDict
+from langgraph.graph.message import add_messages
+from typing import TypedDict, Annotated, List
+from langchain_core.messages import HumanMessage, AIMessage
+
+class State(TypedDict):
+    """
+    Represents the structure of the state used in the graph.
+    """
+    messages: Annotated[list, add_messages]