Upload 10 files

README.md

@@ -1,13 +1,122 @@
----
-title: Chatbotv2
-emoji: 👁
-colorFrom: gray
-colorTo: pink
-sdk: gradio
-sdk_version: 5.20.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# HRMS Email Automation & Legal Assistant Chatbot
+
+## Overview
+This repository contains three separate applications:
+1. **HRMS Email Automation** - A Streamlit-based application for automating HR interview invitation emails.
+2. **Legal Assistant Chatbot** - A Streamlit-based chatbot leveraging Retrieval-Augmented Generation (RAG) for legal assistance.
+3. **Employee Performance & Retention Analytics Dashboard** - A Streamlit-based analytics dashboard providing insights into employee attrition, performance, and retention risk.
+
+---
+
+## 1️⃣ HRMS Email Automation
+
+### Description
+The **HRMS Email Automation** tool simplifies the process of sending interview invitations via email. It provides a user-friendly form to collect candidate details and automatically sends emails for both **Online** and **Face-to-Face** interviews.
+
+### Features
+- Select interview type: **Online** or **Face-to-Face**.
+- Input relevant details like candidate name, interview time, PIC (Person in Charge), and contact details.
+- Validate form fields to ensure required details are entered.
+- Send email automatically using the `EmailAuto` class.
+- User-friendly interface built with **Streamlit**.
+
+### Installation & Usage
+```sh
+# Clone the repository
+git clone https://github.com/your-repo.git
+cd your-repo
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the Streamlit app
+streamlit run email_ui.py
+```
+
+### File Structure
+```
+├── automation/
+│   ├── emailAuto.py  # Handles email automation
+├── email_ui.py  # Streamlit UI for HRMS Email Automation
+```
+
+---
+
+## 2️⃣ Legal Assistant Chatbot
+
+### Description
+The **Legal Assistant Chatbot** is a chatbot designed to provide legal assistance by retrieving relevant legal context from **Pinecone** and responding based on a fine-tuned **TinyLlama** model.
+
+### Features
+- Uses **Retrieval-Augmented Generation (RAG)** for context-aware legal responses.
+- Retrieves legal documents from **Pinecone** to enhance responses.
+- Fine-tuned **TinyLlama-1.1B-Chat** model for legal domain understanding.
+- Interactive chat interface built with **Gradio**.
+- Supports file uploads (optional).
+
+### Installation & Usage
+```sh
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the chatbot
+python app.py
+```
+
+### File Structure
+```
+├── backend/
+│   ├── train.py  # Handles model training
+│   ├── rag.py  # Handles Pinecone-based retrieval
+├── app.py  # Gradio UI for the Legal Assistant Chatbot
+```
+
+---
+
+## 3️⃣ Employee Performance & Retention Analytics Dashboard
+
+### Description
+The **Employee Performance & Retention Analytics Dashboard** provides insights into employee attrition, performance, and retention risk. It includes interactive visualizations, ML-based attrition predictions, and employee-specific evaluations.
+
+### Features
+- **Attrition Prediction:** Uses a RandomForest model to predict employee attrition likelihood.
+- **Performance Analysis:** Visualizations of performance rating, salary, and tenure.
+- **Retention Analysis:** Highlights risks based on job satisfaction, work-life balance, and promotion history.
+- **Employee Evaluation:** Individual employee performance and retention insights.
+- **AI-Powered Insights:** Generates department-specific insights based on filtered employee data.
+
+### Installation & Usage
+```sh
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the Streamlit dashboard
+streamlit run dashboard.py
+```
+
+### File Structure
+```
+├── dashboard.py  # Streamlit UI for HR analytics
+├── HR-Employee-Attrition.csv  # Employee dataset
+```
+
+---
+
+## Environment Variables
+Both applications require environment variables to function correctly. Create a `.env` file and add the following:
+```
+PINECONE_API_KEY=your_pinecone_api_key
+PINECONE_INDEX=your_pinecone_index
+PINECONE_NAMESPACE=your_pinecone_namespace
+```
+
+---
+
+## Contribution
+Feel free to contribute to this project by submitting issues, pull requests, or feature suggestions!
+
+---
+
+## License
+This project is licensed under the MIT License.
+

app.py

@@ -0,0 +1,124 @@
+import gradio as gr
+import logging
+from backend.train import ModelTrainer
+from backend.rag import PineconeRetriever
+from dotenv import load_dotenv
+import os
+
+
+
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+class ChatbotUI:
+    """Class for the Gradio-based chatbot UI with RAG."""
+    def __init__(self, model_name, pinecone_api, pinecone_index, pinecone_namespace):
+        logging.info("Initializing ChatbotUI...")
+        self.trainer = ModelTrainer(model_name)
+        self.retriever = PineconeRetriever(pinecone_api, pinecone_index, pinecone_namespace)
+        logging.info("ChatbotUI initialized successfully.")
+    
+    def chatbot_response(self, input_text, history=None):
+        """Generate response using retrieved context and the trained model."""
+        if history is None:
+            history = []
+        logging.info(f"Received user input: {input_text}")
+        
+        # Retrieve relevant context from Pinecone
+        retrieved_docs = self.retriever.retrieve_context(input_text, top_k=1)
+        logging.info(f"Retrieved context: {retrieved_docs}")  
+        
+        # Preset instruction for the legal assistant
+        preset = "You are a helpful assistant. You do not respond as 'User' or pretend to be 'User'. You only respond once as 'Assistant'."
+        
+        # Combine retrieved context with the user query to form the prompt
+        prompt = f"{preset}\nContext: {retrieved_docs}\nUser: {input_text}\nResponse:"
+        logging.info(f"Generated prompt for TinyLlama: {prompt}")
+
+        # Generate response using the model
+        inputs = self.trainer.tokenizer(prompt, return_tensors="pt").input_ids
+        output = self.trainer.model.generate(inputs, max_length=1000)
+        response = self.trainer.tokenizer.decode(output[0], skip_special_tokens=True)
+        logging.info("Response generated successfully.")
+        
+        # Ensure response does not repeat the prompt
+        if response.startswith(prompt):
+            response = response[len(prompt):].strip()
+
+        # Append the new turn to the conversation history
+        history.append((input_text, response))
+        logging.info(f"Updated conversation history: {history}")
+        
+        return history, ""
+    
+    def clear_conversation(self):
+        """Clears the entire conversation history and resets the input box."""
+        logging.info("Clearing conversation history.")
+        return [], "", []
+
+    # Optional function if you want to process uploaded files:
+    def process_file(self, file):
+        """
+        A placeholder function that can be used to handle file uploads.
+        For instance, you could read the file contents and update the conversation
+        or retrieve additional context from the file. 
+        """
+        if file is not None:
+            logging.info(f"File uploaded: {file.name}")
+            # Example: read the file (if it's text) and do something with it.
+            # with open(file.name, 'r') as f:
+            #     text_data = f.read()
+            #     # Do something with text_data...
+            return "File uploaded successfully!"
+        return "No file uploaded."
+    
+    def launch(self):
+        logging.info("Launching chatbot UI...")
+        with gr.Blocks() as demo:
+            # Title / Header
+            gr.Markdown("<h2 style='text-align: center;'>Legal Assistant Chatbot</h2>")
+            
+            # Main Chatbot component
+            chatbot = gr.Chatbot(label="Chat")
+            
+            # Textbox for user messages
+            msg = gr.Textbox(label="Your Message", placeholder="Enter your message here...")
+            
+            # State to store conversation history
+            state = gr.State([])
+            
+            # Define the function to update the conversation history
+            def user_message(message, chat_history):
+                return self.chatbot_response(message, chat_history)
+            
+            # Submit the user's message
+            msg.submit(user_message, [msg, state], [chatbot, msg])
+            
+            # Clear Chat button
+            clear_btn = gr.Button("Clear Chat")
+            clear_btn.click(fn=self.clear_conversation, 
+                            inputs=[], 
+                            outputs=[chatbot, msg, state],
+                            queue=False)
+            
+            # Optional File Upload (uncomment if you want to enable it)
+            # file_uploader = gr.File(label="Upload a Document")
+            # file_upload_btn = gr.Button("Process File")
+            # file_upload_output = gr.Textbox(label="File Processing Result")
+            # file_upload_btn.click(fn=self.process_file, 
+            #                       inputs=[file_uploader], 
+            #                       outputs=[file_upload_output])
+
+        demo.launch()
+
+if __name__ == "__main__":
+    chatbot = ChatbotUI(
+        # model_name="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+        model_name="sainoforce/modelv3",
+        pinecone_api=os.getenv("PINECONE_API_KEY"),
+        pinecone_index=os.getenv("PINECONE_INDEX"),
+        pinecone_namespace=os.getenv("PINECONE_NAMESPACE")
+    )
+    chatbot.launch()

backend/data.py

@@ -0,0 +1,19 @@
+import pandas as pd
+from datasets import Dataset
+
+class DataLoader:
+    """Class for loading and merging CSV data."""
+    def __init__(self, csv_paths):
+        self.csv_paths = csv_paths
+    
+    def load_data(self):
+        """Load multiple CSV files and merge them into a single dataset."""
+        dataframes = [pd.read_csv(path).dropna() for path in self.csv_paths]
+        combined_df = pd.concat(dataframes, ignore_index=True)
+        return Dataset.from_pandas(combined_df)
+
+if __name__ == "__main__":
+    csv_files = ["data1.csv", "data2.csv"]  # Update with actual file paths
+    data_loader = DataLoader(csv_files)
+    dataset = data_loader.load_data()
+    print(dataset)

backend/rag.py

@@ -0,0 +1,50 @@
+from pinecone import Pinecone
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+class PineconeRetriever:
+    """Class for initializing and querying Pinecone."""
+    def __init__(self, api_key, index_name, namespace):
+        self.api_key = api_key
+        self.index_name = index_name
+        self.namespace = namespace
+        self.pc = Pinecone(api_key=self.api_key)
+        self.index  = self.pc.Index(self.index_name)
+    
+    def retrieve_data(self, query, top_k=1):
+        """Retrieve relevant data from Pinecone."""
+        # Convert the query into a numerical vector that Pinecone can search with
+        query_embedding = self.pc.inference.embed(
+            model="multilingual-e5-large",
+            inputs=[query],
+            parameters={
+                "input_type": "query",
+                "truncate": "END"
+            }
+        )
+
+        results = self.index.query(namespace=self.namespace,
+            vector=query_embedding[0].values,
+            top_k=top_k,
+            include_values=False,
+            include_metadata=True
+        )
+
+        return results
+
+    def retrieve_context(self, query, top_k=1):
+        results = self.retrieve_data(query, top_k)
+        context = ""
+        for match in results['matches']:
+            context += match['metadata']['source_text']
+        return context
+
+if __name__ == "__main__":
+    pinecone_api=os.getenv("PINECONE_API_KEY"),
+    pinecone_index=os.getenv("PINECONE_INDEX"),
+    pinecone_namespace=os.getenv("PINECONE_NAMESPACE")
+    
+    retriever = PineconeRetriever(API_KEY, INDEX_NAME, NAMESPACE)
+    query_result = retriever.retrieve_context("hi")
+    print(query_result)

backend/train.py

@@ -0,0 +1,24 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+class ModelTrainer:
+    """Class for loading and training a TinyLlama model."""
+    def __init__(self, model_name):
+        self.model_name = model_name
+        self.model, self.tokenizer = self.load_model()
+    
+    def load_model(self):
+        """Load a pre-trained model and tokenizer."""
+        print(f"Loading model: {self.model_name}")
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        model = AutoModelForCausalLM.from_pretrained(self.model_name).to(device)
+        tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        return model, tokenizer
+
+if __name__ == "__main__":
+    # Load model directly
+
+    model_name = "sainoforce/modelv2"
+    trainer = ModelTrainer(model_name)
+    print("Model and tokenizer loaded successfully.")

requirements.txt

@@ -0,0 +1,58 @@
+transformers 
+datasets 
+accelerate 
+bitsandbytes 
+peft 
+gradio 
+matplotlib
+numpy 
+pinecone[grpc]
+nltk
+altair==5.5.0
+attrs==25.1.0
+blinker==1.9.0
+cachetools==5.5.2
+certifi==2025.1.31
+charset-normalizer==3.4.1
+click==8.1.8
+colorama==0.4.6
+dotenv==0.9.9
+gitdb==4.0.12
+GitPython==3.1.44
+idna==3.10
+Jinja2==3.1.6
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+MarkupSafe==3.0.2
+narwhals==1.29.1
+numpy==2.2.3
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+protobuf==5.29.3
+pyarrow==19.0.1
+pydeck==0.9.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+pytz==2025.1
+referencing==0.36.2
+requests==2.32.3
+rpds-py==0.23.1
+six==1.17.0
+smmap==5.0.2
+streamlit==1.43.1
+tenacity==9.0.0
+toml==0.10.2
+tornado==6.4.2
+typing_extensions==4.12.2
+tzdata==2025.1
+urllib3==2.3.0
+watchdog==6.0.0
+streamlit
+pandas
+plotly
+scikit-learn
+
+
+
+