app ready

.gitignore

@@ -0,0 +1,5 @@
+.env
+venv/
+__pycache__
+docs
+logs/application.log

app.py

@@ -0,0 +1,52 @@
+import streamlit as st
+from src import utils
+from src.llm import EmotionalChatbot
+from src.log import logger
+
+# Streamlit UI Setup
+st.set_page_config(
+    page_title="Emotional Intelligence Bot",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Initialize session state for chat history
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+try:
+    # Initialize the chatbot
+    chatbot = EmotionalChatbot(chat_history=st.session_state.chat_history)
+except Exception as e:
+    logger.critical("Failed to initialize the chatbot", exc_info=True)
+    st.error("Unable to initialize the bot. Check logs for more details.")
+
+st.markdown(utils.styles(), unsafe_allow_html=True)
+
+st.header(":rainbow[Lumina] - :blue[EI Bot] 🤗")
+
+st.sidebar.markdown(utils.sidebar_markdown())
+
+# Display chat history
+for message in st.session_state.chat_history:
+    for role, content in message.items():
+        with st.chat_message(role):
+            st.write(content)
+
+# User input
+user_input = st.chat_input("Chat With Lumina...")
+if user_input:
+    with st.chat_message("user"):
+        st.write(user_input)
+
+    # Process the user input and generate bot response
+    try:
+        with st.spinner("Thinking..."):
+            response = chatbot.generate_response(user_input)
+            message = {'human':user_input, 'AI':response}
+            st.session_state.chat_history.append(message)
+            with st.chat_message("assistant"):
+                st.write(response)
+    except Exception as e:
+        logger.error(f"Error generating bot response: {e}")
+        st.error("An error occurred. Check logs for more details.")

requirements.txt

@@ -0,0 +1,5 @@
+accelerate
+langchain
+langchain-groq
+python-dotenv
+streamlit

src/config.py

@@ -0,0 +1,32 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class AppConfig:
+    
+    BASE_DIR = os.path.dirname(os.path.dirname(__file__))
+
+    GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+    HF_TOKEN = os.getenv("HF_TOKEN")
+    
+    # SENTI_API_URL = "https://api-inference.huggingface.co/models/distilbert/distilbert-base-uncased-finetuned-sst-2-english"
+    # EMOTION_API_URL = "https://api-inference.huggingface.co/models/bhadresh-savani/distilbert-base-uncased-emotion"
+
+    SYSTEM_PROMPT = (
+        "You are a compassionate and emotionally intelligent AI Assistant."
+        "Your name is Lumina, and you are an emotionally supportive friend."
+        "Your role is to actively listen, understand needs, and respond with kindness, empathy, and positivity."
+        "Respond precisely and clearly (max 20 words for concise responses)."
+        "For detailed empathetic responses, use no more than 30 words."
+    )
+
+    LLM_CONFIG = {
+        "model": "llama3-70b-8192",
+        "api_key": GROQ_API_KEY,
+        "temperature": 0.5,
+        "max_retries": 2,
+        "streaming": True
+    }
+
+    MEMORY_WINDOW = 20

src/exception.py

@@ -0,0 +1,11 @@
+class ChatbotException(Exception):
+    """Base exception for chatbot-related errors."""
+    pass
+
+class LLMLoadingError(ChatbotException):
+    """Exception raised for issues while loading the LLM."""
+    pass
+
+class ResponseGenerationError(ChatbotException):
+    """Exception raised for errors in response generation."""
+    pass

src/llm.py

@@ -0,0 +1,79 @@
+from langchain.chains.conversation.memory import ConversationBufferWindowMemory
+from langchain_groq import ChatGroq
+from langchain.chains import LLMChain
+from langchain_core.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder
+from langchain_core.messages import SystemMessage
+from src.config import AppConfig
+
+class EmotionalChatbot:
+    def __init__(self, chat_history=None):
+        """
+        Initialize the chatbot with Memory and Groq integration.
+        :param chat_history: Existing chat history to load into memory.
+        """
+        self.memory = ConversationBufferWindowMemory(
+            k=AppConfig.MEMORY_WINDOW,
+            memory_key="chat_history",
+            return_messages=True
+        )
+
+        # Load existing chat history into memory if available
+        if chat_history:
+            for message in chat_history:
+                try:
+                    self.memory.save_context(
+                        {"input": message["human"]},
+                        {"output": message["AI"]}
+                    )
+                except KeyError:
+                    print(f"Skipping invalid message: {message}")
+
+        self.default_max_tokens = 100
+
+        # Initialize ChatGroq with default max_tokens
+        self.groq_chat = ChatGroq(**AppConfig.LLM_CONFIG, max_tokens=self.default_max_tokens)
+
+        self.prompt_template = ChatPromptTemplate.from_messages(
+            [
+                SystemMessage(content=AppConfig.SYSTEM_PROMPT),
+                MessagesPlaceholder(variable_name="chat_history"),
+                HumanMessagePromptTemplate.from_template("{human_input}")
+            ]
+        )
+
+        self.conversation = LLMChain(
+            llm=self.groq_chat,
+            prompt=self.prompt_template,
+            memory=self.memory,
+            verbose=True
+        )
+
+    def adjust_max_tokens(self, user_input):
+        """
+        Dynamically adjust the max_tokens based on the user's input complexity.
+        """
+        input_length = len(user_input.split())
+
+        if any(keyword in user_input.lower() for keyword in [
+            "explain", "detail", "elaborate", "describe", "clarify", "expand", 
+            "analyze", "break down", "in-depth", "why", "how", "discuss", 
+            "thorough", "comprehensive", "what do you mean"
+        ]) or input_length >= 15:
+            return self.default_max_tokens  # More tokens for detailed queries
+        else:  # Moderate queries
+            return 50  # Balanced token usage
+
+    def generate_response(self, user_input):
+        """
+        Generate a response using the LLM, with dynamically adjusted max_tokens.
+        :param user_input: The user's message.
+        :return: The AI's response.
+        """
+        # Adjust max_tokens dynamically
+        max_tokens = self.adjust_max_tokens(user_input)
+
+        # Update the LLM configuration dynamically
+        self.groq_chat.max_tokens = max_tokens
+
+        # Generate the response
+        return self.conversation.predict(human_input=user_input)

src/log.py

@@ -0,0 +1,18 @@
+import os
+import logging
+from src.config import AppConfig
+
+
+LOGS_DIR = os.path.join(AppConfig.BASE_DIR, "logs")
+os.makedirs(LOGS_DIR, exist_ok=True)
+
+# Configure logging
+logger = logging.getLogger("EmotionalIntelligenceBot")
+logger.setLevel(logging.INFO)
+
+log_file_path = os.path.join(LOGS_DIR, "application.log")
+
+handler = logging.FileHandler(log_file_path)
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+handler.setFormatter(formatter)
+logger.addHandler(handler)

src/utils.py

@@ -0,0 +1,37 @@
+def styles():
+    css = """
+<style>
+
+</style>
+"""
+    return css
+
+def sidebar_markdown():
+    sidebar_md = """
+# Welcome to Lumina 🤖
+
+---
+
+**Who is Lumina?**  
+Lumina is an emotional intelligence chatbot designed to:  
+- 🧠 Understand your emotions.  
+- ❤️ Provide compassionate responses.  
+- 🌈 Help you feel supported and motivated.
+
+---
+
+**💡 How to use:**  
+1. Share your thoughts or ask a question.  
+2. Lumina will respond with insight and empathy.  
+3. Explore any topic—Lumina is here for you.
+
+---
+
+🎯 **Pro Tip:**  
+The more you engage, the better Lumina understands you. Use this space to express yourself.
+
+---
+
+🌟 **Let Lumina bring light to your day!**
+"""
+    return sidebar_md