Basic chtbot

app.py

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

src/langgraph_agenticAI/Graphs/graph_builder.py

@@ -0,0 +1,73 @@
+from langgraph.graph import StateGraph, START,END, MessagesState
+from langgraph.prebuilt import tools_condition,ToolNode
+from langchain_core.prompts import ChatPromptTemplate
+from src.langgraph_agenticAI.States.state import State
+from src.langgraph_agenticAI.Nodes.basic_chatbot_node import BasicChatbotNode
+from src.langgraph_agenticAI.Nodes.chatbot_with_Tool_node import ChatbotWithToolNode
+from src.langgraph_agenticAI.Tools.search_tool import get_tools,create_tool_node
+
+
+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 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/langgraph_agenticAI/LLMs/GroqLLM.py

@@ -0,0 +1,20 @@
+import os
+import streamlit as st
+from langchain_groq import ChatGroq
+
+class GroqLLM:
+    def __init__(self,user_controls_input):
+        self.user_controls_input=user_controls_input   
+
+    def get_llm_model(self):
+        try:
+            groq_api_key=self.user_controls_input['GROQ_API_KEY']
+            selected_groq_model=self.user_controls_input['selected_groq_model']
+            if groq_api_key=='' and os.environ["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:
+            raise ValueError(f"Error Occurred with Exception : {e}")
+        return llm

src/langgraph_agenticAI/Nodes/basic_chatbot_node.py

@@ -0,0 +1,14 @@
+from src.langgraph_agenticAI.States.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_agenticAI/States/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]

src/langgraph_agenticAI/UI/streamlitui/load_ui.py

@@ -2,11 +2,80 @@ import streamlit as st
 import os
 from datetime import date
 
-from langchain_core import AIMessage, HumanMessage   #because msg we are going to mention in UI is either AImsg or Humanmsg
+#from langchain_core import AIMessage, HumanMessage   #because msg we are going to mention in UI is either AImsg or Humanmsg
 from src.langgraph_agenticAI.UI.uiconfigfile import Config    #Config is class
+
 class LoadStreamLitUI:
     def __init__(self):
         self.config=Config()    #for this cofig we created ini file i.e, uiconfig.ini (text file to store configs in form of key-value pairs) like yaml config. 
-        self.user_controls={}
+        self.user_controls={}    #dictionary
+        
+    def initialize_session(self):
+        return {
+        "current_step": "requirements",
+        "requirements": "",
+        "user_stories": "",
+        "po_feedback": "",
+        "generated_code": "",
+        "review_feedback": "",
+        "decision": None
+    }
+    """ def render_requirements(self):
+        st.markdown('### Requirement Submission')
+        st. session_state.state["requirements"]= st.text_area(
+            "Enter your Requirements:",
+            height=200,
+            key="req-input"
+        )
+        if st.button("Submit requirements", key="req-input"):
+            st.session_state.state["current_step"] = " generate_User_stories" """
+
+
+    def load_streamlit_ui(self):   
+        st.set_page_config(page_title= "🤖 " + self.config.get_page_title(), layout="wide")
+        st.header("🤖 " + self.config.get_page_title())
+        st.session_state.timeframe = ''
+        st.session_state.IsFetchButtonClicked = False
+        st.session_state.IsSDLC = False
+        
+        
+
+        with st.sidebar:     #sidebar for left side code
+            # Get options from config
+            llm_options = self.config.get_llm_options()
+            usecase_options = self.config.get_usecase_options()
+
+            # LLM selection
+            self.user_controls["selected_llm"] = st.selectbox("Select LLM", llm_options)
+
+            if self.user_controls["selected_llm"] == 'Groq':
+                # Model selection
+                model_options = self.config.get_groq_model_options()
+                self.user_controls["selected_groq_model"] = st.selectbox("Select Model", model_options)
+                # API key input
+                self.user_controls["GROQ_API_KEY"] = st.session_state["GROQ_API_KEY"] = st.text_input("API Key",
+                                                                                                      type="password")
+                # Validate API key
+                if not self.user_controls["GROQ_API_KEY"]:
+                    st.warning("⚠️ Please enter your GROQ API key to proceed. Don't have? refer : https://console.groq.com/keys ")
+                   
+            
+            # 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()
+            
+            #self.render_requirements()    #this is to load right side of the page with left sidebar
+        
+        return self.user_controls
 
 

src/langgraph_agenticAI/UI/uiconfigfile.ini

@@ -1,5 +1,5 @@
 [DEFAULT]
-PAGE_TITLE= Langgraph: Build Stateful Agentic AI graph
+PAGE_TITLE = LangGraph: Build Stateful Agentic AI graph
 LLM_OPTIONS= Groq
-USECASE_OPTIONS= Basic Chatbot, Chatbot With Tool, Travel Partner, SDLC Workflow, AI News
+USECASE_OPTIONS= Basic Chatbot
 GROQ_MODEL_OPTIONS= mixtral-8x7b-32768, llama3-8b-8192, llama-70b-8192, gemma-7b-i  

src/langgraph_agenticAI/UI/uiconfigfile.py

@@ -1,18 +1,18 @@
 from configparser import ConfigParser  #class to parse cofig text file
 
 class Config:    #inside any class, we start with constructor
-    def __init__(self,config_file="C:\Users\blues\OneDrive\Documents\E2E_Langraph_Project\src\langgraph_agenticAI\UI\uiconfigfile.ini"):
+    def __init__(self,config_file="./src/langgraph_agenticAI/UI/uiconfigfile.ini"):
         self.config=ConfigParser()   #initialize the constructor, config is public variable , use this configParser object will read the config file and store in config variable
         self.config.read(config_file)
 
-        def get_llm_option(self):    #to only read llm field from config file
-            return self.config["DEFAULT"].get("LLM_OPTIONS").split(", ")   #DEFAULT is root note for all the below node hving access of everything written below
+    def get_llm_options(self):    #to only read llm field from config file
+        return self.config["DEFAULT"].get("LLM_OPTIONS").split(", ")   #DEFAULT is root note for all the below node hving access of everything written below
         
-        def get_usecase_options(self):
-            return self.config["DEFAULT"].get("USECASE_OPTIONS").split(", ")
+    def get_usecase_options(self):
+        return self.config["DEFAULT"].get("USECASE_OPTIONS").split(", ")
 
-        def get_groq_model_options(self):
-            return self.config["DEFAULT"].get("GROQ_MODEL_OPTIONS").split(", ")
+    def get_groq_model_options(self):
+        return self.config["DEFAULT"].get("GROQ_MODEL_OPTIONS").split(", ")
 
-        def get_page_title(self):
-            return self.config["DEFAULT"].get("PAGE_TITLE")
+    def get_page_title(self):
+        return self.config["DEFAULT"].get("PAGE_TITLE")

src/langgraph_agenticAI/main.py

@@ -0,0 +1,62 @@
+import streamlit as st
+import json
+from src.langgraph_agenticAI.UI.streamlitui.load_ui import LoadStreamLitUI
+from src.langgraph_agenticAI.LLMs.GroqLLM import GroqLLM
+from src.langgraph_agenticAI.Graphs.graph_builder import GraphBuilder
+#from src.langgraph_agenticAI.UI.streamlitui.display_result import DisplayResultStreamlit
+
+# 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:      #after we enter message, execution start from here
+            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
+                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}")
+            
+
+