first commit

.gitignore

@@ -0,0 +1,2 @@
+.env
+venv

app.py

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

requirements.txt

@@ -0,0 +1,8 @@
+langchain
+langgraph
+langchain_community
+langchain_core
+langchain_groq
+langchain_openai
+faiss-cpu
+streamlit

src/langgraphagenticai/graph/graph_builder.py

@@ -0,0 +1,22 @@
+from langgraph.graph import StateGraph, END, START, 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
+import datetime
+
+class GraphBuilder:
+    def __init__(self, model):
+        self.llm = model
+        self.graph_builder = StateGraph(State)
+
+    def basic_chatbot_build_graph(self):
+        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):
+        if usecase == "Basic Chatbot":
+            self.basic_chatbot_build_graph()
+        return self.graph_builder.compile()

src/langgraphagenticai/llms/groqllm.py

@@ -0,0 +1,26 @@
+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.get("GROQ_API_KEY")
+            selected_groq_model = self.user_controls_input.get("selected_groq_model")
+
+            if not groq_api_key or not selected_groq_model:
+                st.error("Please enter the GROQ API key and select a model")
+                return None
+
+            llm = ChatGroq(api_key=groq_api_key, model=selected_groq_model)
+            return llm
+        except Exception as e:
+            st.error(f"Error initializing ChatGroq: {str(e)}")
+            print(str(e))
+            return None
+
+        

src/langgraphagenticai/main.py

@@ -0,0 +1,53 @@
+import streamlit as st
+import json
+from src.langgraphagenticai.ui.streamlitui.loadui import LoadStreamlitUI
+from src.langgraphagenticai.llms.groqllm import GroqLLM
+from src.langgraphagenticai.graph.graph_builder import GraphBuilder
+from src.langgraphagenticai.ui.streamlitui.display_result import DisplayResultStremlit
+
+
+# Main function START
+def load_langgraph_agenticai_app():
+    # 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")
+
+    # Text input for user message
+    if st.session_state.IsFetchButtonClicked:
+        user_message = st.session_state.timeframe
+    # elif st.session_state.IsSDLC:
+    #     user_message = st.session_state.state
+    else:
+        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 setup graph based on usecase
+            usecase = user_input.get("selected_usecase")
+            if not usecase:
+                st.error("Error: no usecase selected")
+                return
+
+            # Graph Builder
+            graph_builder = GraphBuilder(model)
+
+            try:
+                graph = graph_builder.setup_graph(usecase=usecase)
+                DisplayResultStremlit(
+                    usecase, graph, user_message
+                ).display_result_on_ui()
+            except Exception as e:
+                st.error(f"Error: Graph setup failed - {e}")
+        except Exception as e:
+            raise ValueError(f"Error occur with exception : {e}")

src/langgraphagenticai/nodes/basic_chatbot_node.py

@@ -0,0 +1,9 @@
+from src.langgraphagenticai.state.state import State
+
+
+class BasicChatbotNode:
+    def __init__(self, model):
+        self.llm = model
+
+    def process(self, state: State):
+        return {"messages": self.llm.invoke(state["messages"])}

src/langgraphagenticai/state/state.py

@@ -0,0 +1,8 @@
+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):
+    messages: Annotated[list, add_messages]

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -0,0 +1,23 @@
+import streamlit as st
+from langchain_core.messages import HumanMessage, AIMessage
+import json
+
+class DisplayResultStremlit:
+    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("assisstant"):
+                        st.write(value["messages"].content)

src/langgraphagenticai/ui/streamlitui/loadui.py

@@ -0,0 +1,96 @@
+import streamlit as st
+import os
+from datetime import date
+
+from langchain_core.messages import AIMessage, HumanMessage
+from src.langgraphagenticai.ui.uiconfigfile import Config
+
+class LoadStreamlitUI:
+    def __init__(self):
+        self.config = Config()
+        self.user_controls = {}
+
+    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("## Requirements Submission")
+        st.session_state.state["requirements"] = st.text_area(
+            "Enter your requirements :",
+            height=200,
+            key="req_input"
+        )
+        if st.button("Submit Requirements", key="submit_req"):
+            st.session_state.state["current_step"] = "generate_user_stories"
+            st.session_state.IsSDLC = True
+
+    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:
+            # 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" or self.user_controls["selected_usecase"] =="AI News" :
+                # 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")
+
+                elif self.user_controls['selected_usecase']=="AI News":
+                    st.subheader("📰 AI News Explorer ")
+                    
+                    with st.sidebar:
+                        time_frame = st.selectbox(
+                            "📅 Select Time Frame",
+                            ["Daily", "Weekly", "Monthly"],
+                            index=0
+                        )
+                    
+                    if st.button("🔍 Fetch Latest AI News", use_container_width=True):
+                        st.session_state.IsFetchButtonClicked = True
+                        st.session_state.timeframe = time_frame
+                    else :
+                        st.session_state.IsFetchButtonClicked = False
+            
+            if "state" not in st.session_state:
+                st.session_state.state = self.initialize_session()
+
+            # self.render_requirements()
+            
+        return self.user_controls

src/langgraphagenticai/ui/uiconfigfile.ini

@@ -0,0 +1,5 @@
+[DEFAULT]
+PAGE_TITLE = Langgraph: Build Stateful Agentic AI graph
+LLM_OPTIONS = Groq
+USECASE_OPTIONS = Basic Chatbot, Chatbot with Tool, AI News
+GROQ_MODEL_OPTIONS = openai/gpt-oss-120b, meta-llama/llama-guard-4-12b, llama-3.3-70b-versatile, openai/gpt-oss-20b

src/langgraphagenticai/ui/uiconfigfile.py

@@ -0,0 +1,19 @@
+from configparser import ConfigParser
+
+
+class Config:
+    def __init__(self, config_file="./src/langgraphagenticai/ui/uiconfigfile.ini"):
+        self.config=ConfigParser()
+        self.config.read(config_file)
+
+    def get_llm_options(self):
+        return self.config["DEFAULT"].get("LLM_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_page_title(self):
+        return self.config["DEFAULT"].get("PAGE_TITLE")