added all the files

Dockerfile

@@ -1,21 +1,27 @@
-FROM python:3.9-slim
+# Use official Python image as base
+FROM python:3.10-slim
 
-WORKDIR /app
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Set work directory
+WORKDIR /app
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Copy project files
+COPY . /app
 
-RUN pip3 install -r requirements.txt
+# Install dependencies
+RUN pip install --upgrade pip \
+    && pip install -r requirements.txt
 
-EXPOSE 8501
+# Expose the port Streamlit will run on
+EXPOSE 7860
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Streamlit-specific environment variables for Hugging Face Spaces
+ENV PORT 7860
+ENV STREAMLIT_SERVER_PORT 7860
+ENV STREAMLIT_SERVER_ADDRESS 0.0.0.0
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Run the Streamlit app
+CMD ["streamlit", "run", "src/langgraphagenticai/app.py"]

README.md

@@ -1,20 +1,135 @@
+# Agentic-AI-Project
 ---
-title: Agenticai App
-emoji: 🚀
-colorFrom: red
+title: LanggraphAgenticAI
+emoji: 🐨
+colorFrom: blue
 colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+sdk: streamlit
+sdk_version: 1.42.0
+app_file: app.py
 pinned: false
-short_description: Streamlit template space
 license: apache-2.0
+short_description: Refined langgraphAgenticAI
 ---
 
-# Welcome to Streamlit!
+### End To End Agentic AI Projects
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+The project is in development
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## 🤖 LangGraph: Build Stateful Agentic AI Graphs
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![Streamlit](https://img.shields.io/badge/streamlit-1.27+-red.svg)](https://streamlit.io/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## 📋 Overview
+
+Agentic-AI-Project leverages the power of LangGraph to enable the creation of stateful, agentic AI workflows. This project provides a modular, extensible framework for building advanced AI agents that can reason, interact, and adapt using graph-based architectures. The intuitive Streamlit UI allows users to configure, run, and visualize agentic workflows with ease.
+
+## ✨ Key Features
+
+- **🔄 Stateful Agentic Graphs:** Build and manage AI agents as nodes in a dynamic graph
+- **🧠 LLM Integration:** Seamless connection to Groq's powerful models
+- **🛠️ Flexible Use Cases:** Pre-built chatbots and tool-enabled agents
+- **🎯 Interactive UI:** User-friendly Streamlit interface
+- **📦 Modular Design:** Extensible architecture for custom capabilities
+
+## 🔄 Use Case Workflow
+
+### 1. UI Configuration
+```python
+# Configure your agent through Streamlit UI
+- Select LLM provider (e.g., Groq)
+- Choose use case (Basic Chatbot/Chatbot with Tool)
+- Pick model from available options
+```
+
+### 2. Agent Interaction Flow
+```mermaid
+graph LR
+    A[User Input] --> B[LLM Processing]
+    B --> C[Graph Execution]
+    C --> D[Tool Usage]
+    D --> E[Response Generation]
+    E --> F[Result Display]
+```
+
+## 🚀 Getting Started
+
+### Prerequisites
+
+- Python 3.8+
+- Git
+- PowerShell
+
+### Installation
+
+```powershell
+# Clone the repository
+git clone <your-repo-url>
+cd langgraph_project
+
+# Create and activate virtual environment
+python -m venv venv
+.\venv\Scripts\Activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+### Running the App
+
+```powershell
+# From the project root
+streamlit run src/langgraphagenticai/app.py
+```
+
+## 📁 Project Structure
+
+```
+src/
+└── langgraphagenticai/
+    ├── app.py              # Application entry point
+    ├── main.py            # Core application logic
+    ├── ui/                # UI components and configuration
+    ├── LLMS/              # LLM integration modules
+    ├── graph/             # Graph construction logic
+    ├── nodes/             # Agent node definitions
+    ├── state/             # State management
+    ├── tools/             # Agent tools and utilities
+    └── vectorstore/       # Vector storage components
+```
+
+## 🛠️ Customization
+
+### Adding New Use Cases
+```python
+# 1. Create a new node in nodes/
+# 2. Define graph logic in graph/
+# 3. Update UI configuration
+```
+
+### Integrating New LLMs
+```python
+# 1. Add LLM wrapper in LLMS/
+# 2. Update uiconfigfile.ini
+# 3. Extend UI options
+```
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgements
+
+- Built with [LangGraph](https://github.com/langchain-ai/langgraph)
+- Powered by [Streamlit](https://streamlit.io/)
+- LLM support by [Groq](https://groq.com/)
+
+---
+
+<div align="center">
+
+**🚀 Empower your AI agents with stateful, agentic reasoning—start building with LangGraph today! 🚀**
+
+</div>

requirements.txt

@@ -1,3 +1,20 @@
-altair
+langchain
+langchain_core
+langchain_community
+langchain-mcp-adapters
+
+python-dotenv
+
+langgraph
+langchain_groq
+langchain_google_genai
+langchain_huggingface
+
+
 pandas
+numpy
+PyPDF2
+
+faiss-cpu
+
 streamlit

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_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/langgraphagenticai/app.py

@@ -0,0 +1,9 @@
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../../")))
+
+from src.langgraphagenticai.main import load_langgraph_agenticai_app
+
+
+if __name__=="__main__":
+    load_langgraph_agenticai_app()

src/langgraphagenticai/graph/graph_builder.py

@@ -0,0 +1,70 @@
+from langgraph.graph import StateGraph, START, END 
+from langgraph.prebuilt  import tools_condition, ToolNode
+from langchain_core.prompts import ChatPromptTemplate
+
+from src.langgraphagenticai.state.state import State
+from src.langgraphagenticai.LLMS.groqllm import GroqLLM
+from src.langgraphagenticai.nodes.basic_chatbot_node import BasicChatbotNode
+from src.langgraphagenticai.tools.search_tool import get_tool, create_tool_node
+from src.langgraphagenticai.nodes.chatbot_with_Tool_node import ChatbotWithToolNode
+
+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 with a single tool node.
+        """
+        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.
+        """
+        
+        # Assuming get_tool() returns a list of tools
+        
+        tools = get_tool()
+        tool_node = create_tool_node(tools)
+        
+        # define the llm
+        llm = self.llm
+        
+        ## Define the tool and tool node
+        obj_chatbot_with_node = ChatbotWithToolNode(self.llm)
+        chatbot = obj_chatbot_with_node.create_chatbot(tools)
+        
+        self.graph_builder.add_node("chatbot", chatbot)
+        self.graph_builder.add_node("tools", tool_node)
+        
+        self.graph_builder.add_edge(START, "chatbot")
+        self.graph_builder.add_conditional_edges("chatbot", tools_condition)
+        self.graph_builder.add_edge("tools", END)
+          
+       
+    def setup_graph(self, usecase):
+        """
+        Sets up the graph based on the selected use case.
+        
+        Args:
+            usecase (str): The selected use case for the graph.
+        """
+        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/langgraphagenticai/main.py

@@ -0,0 +1,66 @@
+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 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:
+            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}")
+            
+
+        
+
+   
+
+    

src/langgraphagenticai/nodes/basic_chatbot_node.py

@@ -0,0 +1,14 @@
+from src.langgraphagenticai.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/langgraphagenticai/nodes/chatbot_with_Tool_node.py

@@ -0,0 +1,42 @@
+from src.langgraphagenticai.state.state import State
+
+class ChatbotWithToolNode:
+    """
+    Chatbot with tool logic implementation.
+    """
+    def __init__(self, model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates a chatbot response with tool invocation.
+        """
+        user_input = state['messages'][-1] if state['messages'] else ""
+        llm_response = self.llm.invoke([{"role": "user", "content": user_input}])
+        
+        # Invoke the LLM with messages and tools
+        # Simulate tool-specific logic
+        tools_response = f"Tool integration for: '{user_input}'"
+        
+        return {"messages": [llm_response, tools_response]}
+    
+    def create_chatbot(self, tools):
+        """
+        Creates a chatbot instance with the configured model.
+        
+        Returns:
+            ChatbotWithToolNode: An instance of the chatbot with tool integration.
+            Returns a chatbot node function that can be used in a LangGraph workflow.
+        """
+        llm_with_tools = self.llm.bind_tools(tools)
+        
+        def chatbot_node(state: State) -> dict:
+            """
+            chatbot logic for processing the input state and generating a response. 
+            """
+            return {"messages": [llm_with_tools.invoke(state["messages"])]}
+        
+        return chatbot_node
+    
+    
+    

src/langgraphagenticai/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]

src/langgraphagenticai/tools/search_tool.py

@@ -0,0 +1,22 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_core.tools import tool
+from langgraph.prebuilt import ToolNode
+
+def get_tool():
+    """
+    Returns a Tool that allows searching using Tavilly.
+    This function creates a Tavilly search tool with a maximum of 5 results.
+    """
+    tools = [TavilySearchResults(max_results=5)]
+    return tools
+    
+def create_tool_node(tools):
+    """
+    Creates a ToolNode for the Tavilly search tool.
+    
+    This function wraps the Tavilly search tool in a ToolNode, allowing it to be used in a LangGraph workflow.
+    
+    Returns:
+        ToolNode: A node that can be used in a LangGraph workflow for search functionality.
+    """
+    return ToolNode(tools=tools)

src/langgraphagenticai/ui/streamlitui/display_result.py

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

src/langgraphagenticai/ui/streamlitui/loadui.py

@@ -0,0 +1,72 @@
+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() # config
+        self.user_controls = {}
+
+    def initialize_session(self):
+        return {
+        "current_step": "requirements",
+        "requirements": "",
+        "user_stories": "",
+        "po_feedback": "",
+        "generated_code": "",
+        "review_feedback": "",
+        "decision": None
+    }
+  
+
+
+    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":
+                # 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()
+            
+            
+        
+        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
+GROQ_MODEL_OPTIONS =  qwen-qwq-32b, llama3-70b-8192, deepseek-r1-distill-llama-70b, meta-llama/llama-4-maverick-17b-128e-instruct

src/langgraphagenticai/ui/uiconfigfile.py

@@ -0,0 +1,26 @@
+from configparser import ConfigParser
+import os
+
+class Config:
+    def __init__(self, config_file=None):
+        # Use os.path for cross-platform compatibility
+        if config_file is None:
+            config_file = os.path.join(
+                "C:/Users/LENOVO/OneDrive - Manipal Academy of Higher Education/GEN AI/Langgraph/langgraph_project/src/langgraphagenticai/ui",
+                "uiconfigfile.ini"
+            )
+        self.config_file = config_file
+        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")

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))