added CI yaml

.github/workflows/main.yml

@@ -0,0 +1,26 @@
+name: Sync to Hugging Face Space
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab 
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: false
+          
+      - name: Ignore large files
+        run : git filter-branch --index-filter 'git rm -rf --cached --ignore-unmatch "Rag_Documents/layout-parser-paper.pdf"' HEAD
+
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push --force https://bpratik:$HF_TOKEN@huggingface.co/spaces/bpratik/Chatbot main
+     
+         

README.md

@@ -0,0 +1,217 @@
+# AI Chatbot with LangGraph and Streamlit
+
+A powerful AI chatbot application built with LangGraph, LangChain, and Streamlit that supports multiple LLM providers including Groq and OpenAI.
+
+## 🚀 Features
+
+- **Multi-LLM Support**: Choose between Groq and OpenAI models
+- **Interactive Chat Interface**: Clean Streamlit-based chat UI
+- **Persistent Chat History**: Conversations are maintained throughout the session
+- **Configurable Models**: Easy model selection and configuration
+- **Graph-Based Architecture**: Built with LangGraph for scalable conversation flows
+- **Real-time Responses**: Streaming responses from AI models
+
+## 🛠️ Tech Stack
+
+- **Frontend**: Streamlit
+- **AI Framework**: LangChain + LangGraph
+- **LLM Providers**: 
+  - Groq (Llama, Gemma models)
+  - OpenAI (GPT-4o, GPT-4o-mini)
+- **State Management**: LangGraph State
+- **Configuration**: ConfigParser
+
+## 📦 Installation
+
+### Prerequisites
+
+- Python 3.8+
+- pip or conda
+
+### Setup
+
+1. **Clone the repository**
+   ```bash
+   git clone <your-repo-url>
+   cd AI-News
+   ```
+
+2. **Create a virtual environment**
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Set up API Keys**
+   
+   You have two options:
+
+   **Option A: Environment Variables (Recommended)**
+   ```bash
+   export GROQ_API_KEY="your_groq_api_key_here"
+   export OPENAI_API_KEY="your_openai_api_key_here"
+   ```
+
+   **Option B: Enter in UI**
+   - Leave environment variables empty
+   - Enter API keys directly in the Streamlit sidebar
+
+## 🔑 Getting API Keys
+
+### Groq API Key
+1. Visit [Groq Console](https://console.groq.com)
+2. Sign up or log in
+3. Navigate to API Keys section
+4. Create a new API key
+
+### OpenAI API Key
+1. Visit [OpenAI Platform](https://platform.openai.com/account/api-keys)
+2. Sign up or log in
+3. Navigate to API Keys section
+4. Create a new API key
+
+## 🚀 Usage
+
+1. **Start the application**
+   ```bash
+   streamlit run app.py
+   ```
+
+2. **Access the app**
+   - Open your browser to `http://localhost:8501`
+
+3. **Configure the chatbot**
+   - Select your preferred LLM provider (Groq or OpenAI)
+   - Choose a model from the dropdown
+   - Enter your API key (if not set as environment variable)
+   - Select a use case
+
+4. **Start chatting**
+   - Type your message in the chat input at the bottom
+   - Press Enter to send
+   - View responses in the chat interface
+
+## 📁 Project Structure
+
+```
+AI-News/
+├── app.py                      # Main application entry point
+├── requirements.txt            # Python dependencies
+├── src/
+│   ├── __init__.py
+│   ├── main.py                 # Core application logic
+│   ├── graph/
+│   │   ├── __init__.py
+│   │   └── graph_builder.py    # LangGraph state graph builder
+│   ├── llms/
+│   │   ├── __init__.py
+│   │   ├── groq.py            # Groq LLM integration
+│   │   └── openai.py          # OpenAI LLM integration
+│   ├── nodes/
+│   │   ├── __init__.py
+│   │   └── basic_chatbot.py   # Chatbot node implementation
+│   ├── state/
+│   │   ├── __init__.py
+│   │   └── state.py           # LangGraph state definition
+│   ├── ui/
+│   │   ├── __init__.py
+│   │   ├── config.ini         # UI configuration
+│   │   ├── config.py          # Configuration loader
+│   │   ├── display_results.py # Results display component
+│   │   └── load.py            # UI loader
+│   ├── tools/
+│   │   └── __init__.py
+│   └── vectorstore/
+       └── __init__.py
+```
+
+## ⚙️ Configuration
+
+The application can be configured through `src/ui/config.ini`:
+
+```ini
+[DEFAULT]
+Title = Basic Chatbot
+USE_CASE = Basic Chatbot, Chatbot with Web Search
+LLM_options = Groq, OpenAI
+GROQ_MODEL = meta-llama/llama-4-scout-17b-16e-instruct, gemma2-9b-it, meta-llama/llama-4-maverick-17b-128e-instruct
+OPENAI_MODEL = gpt-4o, gpt-4o-mini
+```
+
+## 🔧 Available Models
+
+### Groq Models
+- `meta-llama/llama-4-scout-17b-16e-instruct`
+- `gemma2-9b-it`
+- `meta-llama/llama-4-maverick-17b-128e-instruct`
+
+### OpenAI Models
+- `gpt-4o`
+- `gpt-4o-mini`
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **API Key Errors**
+   - Ensure your API key is valid and has sufficient credits
+   - Check if the API key is properly set in environment variables or entered in UI
+
+2. **Import Errors**
+   - Make sure all dependencies are installed: `pip install -r requirements.txt`
+   - Verify you're running from the correct directory
+
+3. **Model Not Found**
+   - Check if the model name in `config.ini` matches the provider's available models
+   - Ensure your API key has access to the selected model
+
+4. **Streamlit Issues**
+   - Clear Streamlit cache: `streamlit cache clear`
+   - Restart the application
+
+### Error Messages
+
+- **"Failed to initialize the model"**: Check API key and model availability
+- **"No use case selected"**: Select a use case from the sidebar dropdown
+- **"Graph must have an entrypoint"**: This indicates a configuration issue - restart the app
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🚧 Future Enhancements
+
+- [ ] **Memory/History Implementation**: Add persistent conversation memory using LangChain's built-in memory features
+- [ ] **Web Search Integration**: Implement web search capabilities for the chatbot
+- [ ] **File Upload Support**: Allow users to upload and chat about documents
+- [ ] **Multiple Conversation Sessions**: Support for multiple concurrent chat sessions
+- [ ] **Custom Model Integration**: Support for additional LLM providers
+- [ ] **Chat Export**: Export conversation history to various formats
+
+## 📞 Support
+
+If you encounter any issues or have questions, please:
+1. Check the troubleshooting section above
+2. Search existing GitHub issues
+3. Create a new issue with detailed information about the problem
+
+## 🙏 Acknowledgments
+
+- [LangChain](https://langchain.com/) for the AI framework
+- [LangGraph](https://langchain-ai.github.io/langgraph/) for state graph implementation
+- [Streamlit](https://streamlit.io/) for the web interface
+- [Groq](https://groq.com/) for fast inference
+- [OpenAI](https://openai.com/) for GPT models

src/graph/graph_builder.py

@@ -10,13 +10,14 @@ class GraphBuilder:
     
     """Class to build the state graph for the application."""
 
-    def __init__(self, model):
+    def __init__(self, model, session_id: str = "default"):
         self.llm = model
+        self.session_id = session_id
         self.graph_builder = StateGraph(State)
     
     def basic_chatbot(self):
         """Initialize the basic chatbot node in the graph."""
-        self.basic_chatbot_node = BasicChatbot(self.llm)
+        self.basic_chatbot_node = BasicChatbot(self.llm, self.session_id)
         self.graph_builder.add_node('basic_chatbot', self.basic_chatbot_node.process)
         self.graph_builder.add_edge(START, 'basic_chatbot')
         self.graph_builder.add_edge('basic_chatbot', END)                                  

src/main.py

@@ -6,7 +6,8 @@ from src.llms.groq import GroqLLM
 from src.llms.openai import OpenAILLM
 from src.graph.graph_builder import GraphBuilder
 from src.ui.display_results import DisplayResults
-from langchain_core.messages import HumanMessage
+from src.memory.memory_manager import MemoryManager
+from langchain_core.messages import HumanMessage, AIMessage
 
 def load_app():
     """
@@ -24,6 +25,14 @@ def load_app():
     if "messages" not in st.session_state:
         st.session_state.messages = []
     
+    # Initialize session ID for memory
+    if "session_id" not in st.session_state:
+        st.session_state.session_id = f"user_{hash(str(st.session_state))}"
+    
+    # Initialize memory manager
+    if "memory_manager" not in st.session_state:
+        st.session_state.memory_manager = MemoryManager()
+    
     # Display chat history
     for message in st.session_state.messages:
         with st.chat_message(message["role"]):
@@ -66,13 +75,20 @@ def load_app():
                 st.error("Error: No use case selected.")
                 return 
           
-            graph_builder = GraphBuilder(model=model)
+            # Use memory-enabled model instead of regular model
+            memory_manager = st.session_state.memory_manager
+            memory_enabled_model, memory_config = memory_manager.create_memory_enabled_model(
+                model, st.session_state.session_id
+            )
+            
+            graph_builder = GraphBuilder(model=memory_enabled_model, session_id=st.session_state.session_id)
 
             try:
                 graph = graph_builder.setup_graph(use_case=use_case)
                 
-                # Process the message through the graph
+                # Process the message through the graph with memory
                 ai_response = ""
+                # Pass just the current message, memory will handle history
                 for event in graph.stream({'messages': [HumanMessage(content=user_message)]}):
                     for value in event.values():
                         ai_response = value['messages'].content

src/memory/__init__.py

@@ -0,0 +1 @@
+# Memory management module

src/memory/memory_manager.py

@@ -0,0 +1,55 @@
+from langchain_community.chat_message_histories import ChatMessageHistory
+from langchain_core.chat_history import BaseChatMessageHistory
+from langchain_core.runnables.history import RunnableWithMessageHistory
+
+class MemoryManager:
+    """
+    Manages chat memory for the chatbot using LangChain's built-in memory features.
+    """
+    
+    def __init__(self):
+        self.store = {}
+    
+    def get_session_history(self, session_id: str) -> BaseChatMessageHistory:
+        """
+        Get or create a chat message history for a given session ID.
+        
+        :param session_id: Unique identifier for the chat session
+        :return: ChatMessageHistory instance for the session
+        """
+        if session_id not in self.store:
+            self.store[session_id] = ChatMessageHistory()
+        return self.store[session_id]
+    
+    def create_memory_enabled_model(self, model, session_id: str = "default"):
+        """
+        Create a model with message history enabled.
+        
+        :param model: The LLM model to wrap with memory
+        :param session_id: Session ID for this conversation
+        :return: Model with message history
+        """
+        with_message_history = RunnableWithMessageHistory(
+            model, 
+            self.get_session_history
+        )
+        
+        config = {"configurable": {"session_id": session_id}}
+        return with_message_history, config
+    
+    def clear_session(self, session_id: str):
+        """
+        Clear the message history for a specific session.
+        
+        :param session_id: Session ID to clear
+        """
+        if session_id in self.store:
+            del self.store[session_id]
+    
+    def get_all_sessions(self):
+        """
+        Get all active session IDs.
+        
+        :return: List of session IDs
+        """
+        return list(self.store.keys())

src/nodes/basic_chatbot.py

@@ -1,25 +1,38 @@
 from src.state.state import State
+from langchain_core.messages import HumanMessage, AIMessage
 
 class BasicChatbot:
     """
-    Class to handle the basic chatbot functionality.
+    Class to handle the basic chatbot functionality with memory.
     """
 
-    def __init__(self, model):
+    def __init__(self, model, session_id: str = "default"):
         """
-        Initialize the BasicChatbot with the given model.
+        Initialize the BasicChatbot with the given model and memory.
         
-        :param model: The LLM to be used for the chatbot.
+        :param model: The LLM to be used for the chatbot (already memory-enabled).
+        :param session_id: Session ID for conversation memory
         """
         self.model = model
+        self.session_id = session_id
+        # Memory config for the model
+        self.memory_config = {"configurable": {"session_id": session_id}}
 
     def process(self, state):
         """
-        Process the state to generate a response from the model.
+        Process the state to generate a response from the model with memory.
         
         :param state: The current state of the chatbot.
         :return: The response generated by the model.
         """
         
-        return {'messages': self.model.invoke(state['messages'])}
+        # Get the messages from the state
+        messages = state['messages']
+        if not messages:
+            return state
+        
+        # Use the memory-enabled model with session config
+        response = self.model.invoke(messages, config=self.memory_config)
+        
+        return {'messages': response}
        

src/ui/load.py

@@ -62,6 +62,25 @@ class LoadStreamlitUI:
       # Use Case Selection
       self.user_controls['Selected Use Case'] = st.selectbox('Select Use Case', use_case)
 
+      # Memory Management Section
+      st.divider()
+      st.subheader("💭 Memory Management")
+      
+      # Display current session ID
+      if "session_id" in st.session_state:
+          st.text(f"Session: {st.session_state.session_id[-8:]}")  # Show last 8 characters
+      
+      # Clear conversation button
+      if st.button("🗑️ Clear Conversation", help="Clear chat history and start fresh"):
+          if "messages" in st.session_state:
+              st.session_state.messages = []
+          if "memory_manager" in st.session_state and "session_id" in st.session_state:
+              # Clear the session from memory manager
+              st.session_state.memory_manager.clear_session(st.session_state.session_id)
+              # Create new session ID
+              st.session_state.session_id = f"user_{hash(str(st.session_state))}"
+          st.rerun()
+
 
     if 'state' not in st.session_state:
       st.session_state.state = self.initialize_session()