Upload 21 files

app.py

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

src/langgraphagenticai/LLMS/groqllm.py

@@ -0,0 +1,20 @@
+import os
+import streamlit as st
+from langchain_groq import ChatGroq
+
+class GroqLLM:
+    def __init__(self,user_contols_input):
+        self.user_controls_input=user_contols_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 Ocuured With Exception : {e}")
+        return llm

src/langgraphagenticai/graph/graph_builder.py

@@ -0,0 +1,135 @@
+from langgraph.graph import StateGraph
+from src.langgraphagenticai.state.state import State
+from langgraph.graph import START, END
+from src.langgraphagenticai.nodes.basic_chatbot_node import BasicChatbotNode
+from src.langgraphagenticai.tools.search_tool import get_tools, create_tool_node
+from langgraph.prebuilt import tools_condition, ToolNode
+from src.langgraphagenticai.nodes.chatbot_with_Tool_node import ChatbotWithToolNode
+from src.langgraphagenticai.nodes.ai_news_node import AINewsNode
+
+
+class GraphBuilder:
+    def __init__(self, model):
+        """
+        Initializes the GraphBuilder class.
+
+        Args:
+            model: The language model (LLM) to be used in nodes.
+        """
+        # Store the provided language model
+        self.llm = model
+
+        # Initialize a StateGraph — the core structure used by LangGraph
+        # to define workflows (nodes and their connections).
+        self.graph_builder = StateGraph(State)
+
+    # ----------------------------------------------------------------------
+    def basic_chatbot_build_graph(self):
+        """
+        Builds a simple chatbot workflow graph.
+
+        The graph consists of only one node (the chatbot node) that:
+        - Takes a user message as input
+        - Returns an AI-generated reply
+        - Starts and ends at this single node
+        """
+
+        # Create an instance of the basic chatbot node using the LLM
+        self.basic_chatbot_node = BasicChatbotNode(self.llm)
+
+        # Add a node named "chatbot" and assign its processing function
+        self.graph_builder.add_node("chatbot", self.basic_chatbot_node.process)
+
+        # Define the flow of the graph:
+        # Start → chatbot → End
+        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 workflow that can use external tools.
+
+        This graph includes:
+        - A chatbot node (main conversation handler)
+        - A tools node (used when external info or web data is needed)
+        - Conditional edges to decide when to call tools
+        """
+
+        # 1️⃣ Load the external tools (e.g., web search APIs)
+        tools = get_tools()
+
+        # 2️⃣ Create a LangGraph ToolNode using those tools
+        tool_node = create_tool_node(tools)
+
+        # 3️⃣ Initialize the LLM
+        llm = self.llm
+
+        # 4️⃣ Create a chatbot node that supports tool calling
+        obj_chatbot_with_node = ChatbotWithToolNode(llm)
+        chatbot_node = obj_chatbot_with_node.create_chatbot(tools)
+
+        # 5️⃣ Add both chatbot and tool nodes to the graph
+        self.graph_builder.add_node("chatbot", chatbot_node)
+        self.graph_builder.add_node("tools", tool_node)
+
+        # 6️⃣ Define how data flows between nodes:
+        # Start → Chatbot
+        self.graph_builder.add_edge(START, "chatbot")
+
+        # From chatbot → tools (conditionally, only when the chatbot needs to call a tool)
+        self.graph_builder.add_conditional_edges("chatbot", tools_condition)
+
+        # From tools → chatbot (after tool execution, control returns to chatbot)
+        self.graph_builder.add_edge("tools", "chatbot")
+
+    # ----------------------------------------------------------------------
+    def ai_news_builder_graph(self):
+        """
+        Builds a graph for the AI News use case.
+
+        This workflow automates:
+        1. Fetching AI-related news from the web (Tavily API)
+        2. Summarizing it using an LLM
+        3. Saving the result as a markdown file
+        """
+
+        # Create an AI news node object (handles fetch, summarize, and save)
+        ai_news_node = AINewsNode(self.llm)
+
+        # Add nodes for each stage of the process
+        self.graph_builder.add_node("fetch_news", ai_news_node.fetch_news)
+        self.graph_builder.add_node("summarize_news", ai_news_node.summarize_news)
+        self.graph_builder.add_node("save_result", ai_news_node.save_result)
+
+        # Define the flow of the process:
+        # fetch_news → summarize_news → save_result → End
+        self.graph_builder.set_entry_point("fetch_news")
+        self.graph_builder.add_edge("fetch_news", "summarize_news")
+        self.graph_builder.add_edge("summarize_news", "save_result")
+        self.graph_builder.add_edge("save_result", END)
+
+    # ----------------------------------------------------------------------
+    def setup_graph(self, usecase: str):
+        """
+        Builds and compiles the appropriate LangGraph workflow
+        based on the selected use case.
+
+        Args:
+            usecase (str): The name of the selected use case.
+                           Options: "Basic Chatbot", "Chatbot With Web", "AI News"
+
+        Returns:
+            Compiled graph object ready for execution.
+        """
+
+        # Based on the selected use case, build the appropriate graph
+        if usecase == "Basic Chatbot":
+            self.basic_chatbot_build_graph()
+        if usecase == "Chatbot With Web":
+            self.chatbot_with_tools_build_graph()
+        if usecase == "AI News":
+            self.ai_news_builder_graph()
+
+        # Compile the graph so it can be executed by LangGraph
+        return self.graph_builder.compile()

src/langgraphagenticai/main.py

@@ -0,0 +1,78 @@
+import streamlit as st
+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 DisplayResultStreamlit
+
+
+def load_langgraph_agenticai_app():
+    """
+    Loads and runs the LangGraph AgenticAI application using Streamlit.
+    
+    This function:
+    1. Initializes and loads the Streamlit UI components.
+    2. Reads user inputs such as selected use case and model options.
+    3. Sets up the appropriate LLM (Groq-based).
+    4. Builds a LangGraph workflow based on the selected use case.
+    5. Executes the workflow and displays results interactively.
+    
+    Includes robust exception handling to provide meaningful Streamlit error messages.
+    """
+
+    # Step 1: Load the Streamlit-based user interface
+    ui = LoadStreamlitUI()
+    user_input = ui.load_streamlit_ui()
+
+    # If UI failed to return valid inputs, display error and exit
+    if not user_input:
+        st.error("Error: Failed to load user input from the UI.")
+        return
+    
+    # Step 2: Capture user input message based on interaction type
+    # If user clicked a button to fetch AI news → use the 'timeframe' value (daily/weekly/monthly)
+    # Otherwise, show a chat input box for general chatbot interaction
+    if st.session_state.IsFetchButtonClicked:
+        user_message = st.session_state.timeframe 
+    else:
+        user_message = st.chat_input("Enter your message:")
+
+    # Continue only if a message was provided
+    if user_message:
+        try:
+            # Step 3: Initialize and configure the selected LLM model (e.g., Groq’s Llama)
+            obj_llm_config = GroqLLM(user_contols_input=user_input)
+            model = obj_llm_config.get_llm_model()
+
+            # If model setup fails, show error and stop execution
+            if not model:
+                st.error("Error: LLM model could not be initialized.")
+                return
+            
+            # Step 4: Get the selected use case (e.g., Basic Chatbot / Chatbot With Web / AI News)
+            usecase = user_input.get("selected_usecase")
+
+            if not usecase:
+                st.error("Error: No use case selected.")
+                return
+            
+            # Step 5: Build the corresponding LangGraph for the chosen use case
+            graph_builder = GraphBuilder(model)
+            try:
+                # Compile the graph (depending on use case type)
+                graph = graph_builder.setup_graph(usecase)
+                
+                # Print user message in terminal/log for debugging purposes
+                print(user_message)
+
+                # Step 6: Display the result on the Streamlit UI
+                DisplayResultStreamlit(usecase, graph, user_message).display_result_on_ui()
+            
+            except Exception as e:
+                # Handle graph-building specific errors
+                st.error(f"Error: Graph setup failed - {e}")
+                return
+
+        except Exception as e:
+            # Handle any general exception (e.g., model or UI failure)
+            st.error(f"Error: Unexpected issue occurred - {e}")
+            return

src/langgraphagenticai/nodes/ai_news_node.py

@@ -0,0 +1,131 @@
+from tavily import TavilyClient
+from langchain_core.prompts import ChatPromptTemplate
+
+
+class AINewsNode:
+    def __init__(self, llm):
+        """
+        Initializes the AI News Node.
+
+        This class handles fetching and summarizing recent AI-related news
+        using Tavily (a web search API) and an LLM (language model such as Groq).
+
+        Args:
+            llm: The language model used for generating summaries.
+        """
+        # Create an instance of Tavily client to perform news searches
+        self.tavily = TavilyClient()
+        # Store the LLM (used later for summarization)
+        self.llm = llm
+        # A dictionary to store intermediate data such as frequency, fetched news, and summaries
+        self.state = {}
+
+    # ----------------------------------------------------------------------
+    def fetch_news(self, state: dict) -> dict:
+        """
+        Fetch AI-related news articles using the Tavily API.
+
+        Args:
+            state (dict): The current graph state, expected to include
+                          'messages' containing the news frequency (e.g., daily, weekly, monthly).
+
+        Returns:
+            dict: Updated state with 'news_data' containing the fetched news articles.
+        """
+
+        # Extract frequency from user input (e.g., "daily", "weekly", etc.)
+        frequency = state['messages'][0].content.lower()
+        self.state['frequency'] = frequency
+
+        # Mapping for Tavily's time range codes and days
+        time_range_map = {'daily': 'd', 'weekly': 'w', 'monthly': 'm', 'year': 'y'}
+        days_map = {'daily': 1, 'weekly': 7, 'monthly': 30, 'year': 366}
+
+        # Perform a Tavily API search for the latest AI news
+        response = self.tavily.search(
+            query="Top Artificial Intelligence (AI) technology news globally",
+            topic="news",
+            time_range=time_range_map[frequency],  # How far back to look
+            include_answer="advanced",             # Request detailed information
+            max_results=20,                        # Limit number of news items
+            days=days_map[frequency],              # Number of days to consider
+            # include_domains=["techcrunch.com", "venturebeat.com/ai", ...]  # (Optional) restrict sources
+        )
+
+        # Store the fetched results in the state dictionary
+        state['news_data'] = response.get('results', [])
+        self.state['news_data'] = state['news_data']
+
+        return state
+
+    # ----------------------------------------------------------------------
+    def summarize_news(self, state: dict) -> dict:
+        """
+        Summarize the fetched AI news articles using the provided LLM.
+
+        Args:
+            state (dict): The current graph state containing 'news_data'.
+
+        Returns:
+            dict: Updated state with 'summary' containing the summarized news in markdown format.
+        """
+
+        # Get the list of fetched news articles
+        news_items = self.state['news_data']
+
+        # Define how the summary should be formatted (markdown structure)
+        prompt_template = ChatPromptTemplate.from_messages([
+            ("system", """Summarize AI news articles into markdown format. For each item include:
+            - Date in **YYYY-MM-DD** format (IST timezone)
+            - A concise summary of the news
+            - Sorted by latest date first
+            - Include the source URL as a hyperlink
+            Use this format:
+            ### [Date]
+            - [Summary](URL)"""),
+            ("user", "Articles:\n{articles}")
+        ])
+
+        # Convert each article into a formatted string with content, URL, and publication date
+        articles_str = "\n\n".join([
+            f"Content: {item.get('content', '')}\nURL: {item.get('url', '')}\nDate: {item.get('published_date', '')}"
+            for item in news_items
+        ])
+
+        # Ask the LLM to generate a markdown summary from the provided articles
+        response = self.llm.invoke(prompt_template.format(articles=articles_str))
+
+        # Save the summary to the state
+        state['summary'] = response.content
+        self.state['summary'] = state['summary']
+
+        return self.state
+
+    # ----------------------------------------------------------------------
+    def save_result(self, state):
+        """
+        Save the summarized AI news to a markdown (.md) file.
+
+        Args:
+            state (dict): The current graph state (contains 'frequency' and 'summary').
+
+        Returns:
+            dict: Updated state with 'filename' indicating where the summary file was saved.
+        """
+
+        # Retrieve frequency and summary content from the state
+        frequency = self.state['frequency']
+        summary = self.state['summary']
+
+        # Define output file path (e.g., ./AINews/daily_summary.md)
+        filename = f"./AINews/{frequency}_summary.md"
+
+        # Write the summary content to a markdown file
+        with open(filename, 'w') as f:
+            f.write(f"# {frequency.capitalize()} AI News Summary\n\n")
+            f.write(summary)
+
+        # Save filename in the state for reference
+        self.state['filename'] = filename
+
+        return self.state

src/langgraphagenticai/nodes/basic_chatbot_node.py

@@ -0,0 +1,15 @@
+from src.langgraphagenticai.state.state import State
+
+class BasicChatbotNode:
+    """
+    Basic Chatbot login 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/langgraphagenticai/nodes/chatbot_with_Tool_node.py

@@ -0,0 +1,36 @@
+from src.langgraphagenticai.state.state import State
+
+class ChatbotWithToolNode:
+    """
+    Chatbot logic enhanced with tool integration.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates a response with tool integration.
+        """
+        user_input = state["messages"][-1] if state["messages"] else ""
+        llm_response = self.llm.invoke([{"role": "user", "content": user_input}])
+
+        # Simulate tool-specific logic
+        tools_response = f"Tool integration for: '{user_input}'"
+
+        return {"messages": [llm_response, tools_response]}
+    
+
+    def create_chatbot(self, tools):
+        """
+        Returns a chatbot node function.
+        """
+        llm_with_tools = self.llm.bind_tools(tools)
+
+        def chatbot_node(state: State):
+            """
+            Chatbot logic for processing the input state and returning a response.
+            """
+            return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+        return chatbot_node
+

src/langgraphagenticai/state/state.py

@@ -0,0 +1,10 @@
+from typing_extensions import TypedDict,List
+from langgraph.graph.message import add_messages
+from typing import Annotated
+
+
+class State(TypedDict):
+    """
+    Represent the structure of the state used in graph
+    """
+    messages: Annotated[List,add_messages]

src/langgraphagenticai/tools/search_tool.py

@@ -0,0 +1,16 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langgraph.prebuilt import ToolNode
+
+def get_tools():
+    """
+    Return the list of tools to be used in the chatbot
+    """
+    tools=[TavilySearchResults(max_results=2)]
+    return tools
+
+def create_tool_node(tools):
+    """
+    creates and returns a tool node for the graph
+    """
+    return ToolNode(tools=tools)
+

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -0,0 +1,103 @@
+import streamlit as st
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
+import json
+
+
+# This class is responsible for displaying the output/results
+# of the Agentic AI workflows in the Streamlit user interface (UI).
+class DisplayResultStreamlit:
+    def __init__(self, usecase, graph, user_message):
+        # Store the selected use case (e.g., Basic Chatbot, Chatbot With Web, AI News)
+        self.usecase = usecase
+        # Store the LangGraph graph object (the AI workflow graph to execute)
+        self.graph = graph
+        # Store the user's input message (what the user typed or selected)
+        self.user_message = user_message
+
+    # Main function that runs the AI process and displays the results in Streamlit
+    def display_result_on_ui(self):
+        # Extract class variables for easier access
+        usecase = self.usecase
+        graph = self.graph
+        user_message = self.user_message
+
+        print(user_message)  # For debugging – shows user message in console
+
+        # ---------------------------
+        # 1️⃣ USE CASE: BASIC CHATBOT
+        # ---------------------------
+        if usecase == "Basic Chatbot":
+            # The chatbot processes the user message in a streaming manner (real-time updates)
+            for event in graph.stream({'messages': ("user", user_message)}):
+                print(event.values())  # Debug: print current event values
+
+                for value in event.values():
+                    print(value['messages'])  # Debug: print the message object
+
+                    # Display user's message in the chat interface
+                    with st.chat_message("user"):
+                        st.write(user_message)
+
+                    # Display the AI’s reply in the chat interface
+                    with st.chat_message("assistant"):
+                        st.write(value["messages"].content)
+
+        # ---------------------------------
+        # 2️⃣ USE CASE: CHATBOT WITH WEB
+        # ---------------------------------
+        elif usecase == "Chatbot With Web":
+            # Initialize the message state for the graph to process
+            initial_state = {"messages": [user_message]}
+
+            # Invoke the Agentic AI graph once (non-streaming)
+            res = graph.invoke(initial_state)
+
+            # Iterate through each message in the result
+            for message in res['messages']:
+                # Display human messages
+                if type(message) == HumanMessage:
+                    with st.chat_message("user"):
+                        st.write(message.content)
+
+                # Display tool messages (e.g., web search or API calls made by the agent)
+                elif type(message) == ToolMessage:
+                    with st.chat_message("ai"):
+                        st.write("Tool Call Start")
+                        st.write(message.content)
+                        st.write("Tool Call End")
+
+                # Display AI (assistant) messages
+                elif type(message) == AIMessage and message.content:
+                    with st.chat_message("assistant"):
+                        st.write(message.content)
+
+        # -------------------------------
+        # 3️⃣ USE CASE: AI NEWS GENERATOR
+        # -------------------------------
+        elif usecase == "AI News":
+            # In this mode, the user_message stores the frequency (Daily, Weekly, Monthly)
+            frequency = self.user_message
+
+            # Show a loading spinner while news is being fetched and summarized
+            with st.spinner("Fetching and summarizing news... ⏳"):
+                # Invoke the graph to trigger the AI News workflow
+                result = graph.invoke({"messages": frequency})
+
+                try:
+                    # Construct file path to the generated Markdown summary
+                    AI_NEWS_PATH = f"./AINews/{frequency.lower()}_summary.md"
+
+                    # Open and read the markdown file content
+                    with open(AI_NEWS_PATH, "r") as file:
+                        markdown_content = file.read()
+
+                    # Display the markdown summary nicely in Streamlit
+                    st.markdown(markdown_content, unsafe_allow_html=True)
+
+                # Handle cases where the markdown file does not exist
+                except FileNotFoundError:
+                    st.error(f"News Not Generated or File not found: {AI_NEWS_PATH}")
+
+                # Handle other unexpected errors gracefully
+                except Exception as e:
+                    st.error(f"An error occurred: {str(e)}")

src/langgraphagenticai/ui/streamlitui/loadui.py

@@ -0,0 +1,88 @@
+import streamlit as st
+import os
+from src.langgraphagenticai.ui.uiconfigfile import Config
+
+# This class is responsible for creating and managing the Streamlit user interface (UI)
+# for the LangGraph Agentic AI application.
+class LoadStreamlitUI:
+    def __init__(self):
+        # Initialize the configuration object (reads from uiconfigfile.ini)
+        self.config = Config()
+        # A dictionary to store user-selected UI control values (e.g., LLM, model, API keys)
+        self.user_controls = {}
+
+    # Main function to load and display all Streamlit UI components
+    def load_streamlit_ui(self):
+        # Set page configuration such as title and layout
+        st.set_page_config(
+            page_title="🤖 " + self.config.get_page_title(),
+            layout="wide"
+        )
+
+        # Display the main page header
+        st.header("🤖 " + self.config.get_page_title())
+
+        # Initialize session variables for controlling UI behavior
+        st.session_state.timeframe = ''
+        st.session_state.IsFetchButtonClicked = False
+
+        # Everything inside 'with st.sidebar' will appear in the left sidebar
+        with st.sidebar:
+            # Retrieve configuration options (LLMs and Use Cases)
+            llm_options = self.config.get_llm_options()
+            usecase_options = self.config.get_usecase_options()
+
+            # Dropdown to select which LLM provider to use (e.g., Groq)
+            self.user_controls["selected_llm"] = st.selectbox("Select LLM", llm_options)
+
+            # If user chooses 'Groq' as LLM, show additional Groq-specific inputs
+            if self.user_controls["selected_llm"] == 'Groq':
+                # Get Groq model list from config file
+                model_options = self.config.get_groq_model_options()
+
+                # Dropdown to select which Groq model to use (e.g., llama-3.1-8b)
+                self.user_controls["selected_groq_model"] = st.selectbox("Select Model", model_options)
+
+                # Textbox for entering Groq API key (masked as password)
+                self.user_controls["GROQ_API_KEY"] = st.session_state["GROQ_API_KEY"] = st.text_input(
+                    "API Key", type="password"
+                )
+
+                # Show a warning if the API key is not entered
+                if not self.user_controls["GROQ_API_KEY"]:
+                    st.warning("⚠️ Please enter your GROQ API key to proceed. Don't have one? Visit: https://console.groq.com/keys")
+
+            # Dropdown to select which use case to run (e.g., Basic Chatbot, Chatbot With Web, AI News)
+            self.user_controls["selected_usecase"] = st.selectbox("Select Usecases", usecase_options)
+
+            # If the selected use case involves web search or news fetching,
+            # ask for the Tavily API key (used for web search capabilities)
+            if self.user_controls["selected_usecase"] in ["Chatbot With Web", "AI News"]:
+                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"
+                )
+
+                # Show a warning if Tavily API key is not entered
+                if not self.user_controls["TAVILY_API_KEY"]:
+                    st.warning("⚠️ Please enter your TAVILY_API_KEY to proceed. Don't have one? Visit: https://app.tavily.com/home")
+
+            # If the user selects "AI News" use case, show additional news-specific options
+            if self.user_controls['selected_usecase'] == "AI News":
+                st.subheader("📰 AI News Explorer ")
+
+                # Allow user to choose the time frame for news updates
+                with st.sidebar:
+                    time_frame = st.selectbox(
+                        "📅 Select Time Frame",
+                        ["Daily", "Weekly", "Monthly"],
+                        index=0
+                    )
+
+                # Button to trigger fetching AI news
+                if st.button("🔍 Fetch Latest AI News", use_container_width=True):
+                    # Mark that the fetch button was clicked and store selected time frame
+                    st.session_state.IsFetchButtonClicked = True
+                    st.session_state.timeframe = time_frame
+
+        # Return all collected user input values for further processing
+        return self.user_controls

src/langgraphagenticai/ui/uiconfigfile.ini

@@ -0,0 +1,17 @@
+[DEFAULT]
+# This section defines default configuration settings 
+# that the Streamlit UI or app will use.
+
+# Title text that appears at the top of the Streamlit web page.
+PAGE_TITLE = LangGraph: Agentic AI
+
+# List of available Large Language Model (LLM) providers shown in the UI dropdown.
+LLM_OPTIONS = Groq
+
+# List of available use cases that users can select from in the app.
+# For example: a simple chatbot, a chatbot that can browse the web, or an AI news assistant.
+USECASE_OPTIONS = Chatbot, Chatbot With Web, AI News
+
+# List of model names available when the selected LLM provider is "Groq".
+# These are Groq-hosted versions of Meta’s Llama models with different sizes and capabilities.
+GROQ_MODEL_OPTIONS = llama-3.1-8b-instant, llama-3.3-70b-versatile

src/langgraphagenticai/ui/uiconfigfile.py

@@ -0,0 +1,20 @@
+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")
+