Upload 2 files

main_v1.py

@@ -0,0 +1,467 @@
+import streamlit as st
+import pandas as pd
+import rag  # Import the rag module
+import os   # Import os for file path handling
+
+def main():
+    st.set_page_config(layout="wide", page_title="Communication Board")
+
+    # --- Session State Initialization ---
+    # Check specifically for 'assistant' to ensure it's initialized
+    if 'assistant' not in st.session_state:
+        st.session_state.current_page = "main"
+        st.session_state.show_custom_words = False
+        st.session_state.custom_words = []
+        st.session_state.text_size = 22
+        st.session_state.theme = "Default"
+        st.session_state.speech_rate = 1.0
+        st.session_state.voice_option = "Default Voice"
+        st.session_state.messages = []
+        st.session_state.assistant = None
+        # Initialize text_output only if assistant is not initialized, assuming they go together
+        st.session_state.text_output = ""
+
+    # --- Theme Colors ---
+    theme_colors = {
+        "Default": {
+            "bg": "#FFFFFF", "text": "#000000",
+            "pronoun": "#FFFF99", "verb": "#CCFFCC", 
+            "question": "#CCCCFF", "common": "#FFCC99",
+            "preposition": "#99CCFF", "descriptive": "#CCFF99",
+            "misc": "#FFB6C1"
+        },
+        "High Contrast": {
+            "bg": "#FFFFFF", "text": "#000000",
+            "pronoun": "#FFFF00", "verb": "#00FF00",
+            "question": "#0000FF", "common": "#FF6600",
+            "preposition": "#00CCFF", "descriptive": "#66FF33",
+            "misc": "#FF3366"
+        },
+        "Pastel": {
+            "bg": "#F8F8FF", "text": "#333333",
+            "pronoun": "#FFEFD5", "verb": "#E0FFFF",
+            "question": "#D8BFD8", "common": "#FFE4B5",
+            "preposition": "#B0E0E6", "descriptive": "#F0FFF0",
+            "misc": "#FFF0F5"
+        },
+        "Dark Mode": {
+            "bg": "#333333", "text": "#FFFFFF",
+            "pronoun": "#8B8B00", "verb": "#006400",
+            "question": "#00008B", "common": "#8B4500",
+            "preposition": "#00688B", "descriptive": "#698B22",
+            "misc": "#8B1A1A"
+        }
+    }
+    colors = theme_colors[st.session_state.theme]
+
+    # --- Helper Function to Initialize Assistant (Adapted from previous main.py) ---
+    @st.cache_resource # Cache the assistant
+    def initialize_assistant(doc_path):
+        """Initializes the AACAssistant."""
+        # Create a dummy document if it doesn't exist for demonstration
+        if not os.path.exists(doc_path):
+            st.sidebar.warning(f"Doc '{os.path.basename(doc_path)}' not found. Creating dummy.")
+            try:
+                with open(doc_path, "w") as f:
+                    f.write("""
+                    I grew up in Seattle and love the rain.
+                    My favorite hobby is playing chess.
+                    I have a dog named Max.
+                    I studied computer science.
+                    I enjoy sci-fi movies.
+                    """)
+            except Exception as e:
+                st.sidebar.error(f"Failed to create dummy doc: {e}")
+                return None
+        try:
+            assistant = rag.AACAssistant(doc_path)
+            st.sidebar.success("AAC Assistant Initialized.")
+            return assistant
+        except Exception as e:
+            st.sidebar.error(f"Error initializing AAC Assistant: {e}")
+            st.sidebar.error("Ensure Ollama/LM Studio running.")
+            return None
+
+    DEFAULT_DOCUMENT_PATH = "aac_user_experiences.txt"
+
+    # --- CSS Styling ---
+    css = f"""
+    <style>
+        .big-font {{
+            font-size:{st.session_state.text_size}px !important;
+            text-align: center;
+        }}
+        .output-box {{
+            border: 2px solid #ddd;
+            border-radius: 5px;
+            padding: 15px;
+            min-height: 100px;
+            background-color: white;
+            margin-bottom: 15px;
+            font-size: {st.session_state.text_size}px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }}
+        div[data-testid="stHorizontalBlock"] {{
+            gap: 5px;
+        }}
+        section[data-testid="stSidebar"] {{
+            width: 20rem;
+            background-color: {colors["bg"]};
+        }}
+        body {{
+            background-color: {colors["bg"]};
+            color: {colors["text"]};
+        }}
+        .stButton>button {{
+            width: 100%;
+            height: 60px;
+            font-size: {max(16, st.session_state.text_size - 6)}px;
+            font-weight: bold;
+            white-space: normal;
+            padding: 0px;
+            transition: transform 0.1s ease;
+        }}
+        .stButton>button:hover {{
+            filter: brightness(95%);
+            transform: scale(1.03);
+            box-shadow: 0 2px 3px rgba(0,0,0,0.1);
+        }}
+        .control-button {{
+            height: 80px !important;
+            font-size: {max(18, st.session_state.text_size - 4)}px !important;
+        }}
+        .btn-pronoun {{
+            background-color: {colors["pronoun"]} !important;
+            border: 1px solid #888 !important;
+        }}
+        .btn-verb {{
+            background-color: {colors["verb"]} !important;
+            border: 1px solid #888 !important;
+        }}
+        .btn-question {{
+            background-color: {colors["question"]} !important;
+            border: 1px solid #888 !important;
+        }}
+        .btn-common {{
+            background-color: {colors["common"]} !important;
+            border: 1px solid #888 !important;
+        }}
+        .btn-preposition {{
+            background-color: {colors["preposition"]} !important;
+            border: 1px solid #888 !important;
+        }}
+        .btn-descriptive {{
+            background-color: {colors["descriptive"]} !important;
+            border: 1px solid #888 !important;
+        }}
+        .btn-misc {{
+            background-color: {colors["misc"]} !important;
+            border: 1px solid #888 !important;
+        }}
+        /* Sidebar chat styling */
+        .sidebar .stChatMessage {{
+            background-color: {colors.get('bg', '#FFFFFF')}; /* Use theme background */
+            border-radius: 8px;
+        }}
+    </style>
+    """
+
+    # --- JS for Button Coloring (no delay, no setTimeout) ---
+    js = """
+    <script>
+        function colorButtons() {
+            const buttons = document.querySelectorAll('button[id^="key_"]');
+            buttons.forEach(button => {
+                const id = button.id;
+                const parts = id.split('_');
+                if (parts.length >= 4) {
+                    const category = parts[3];
+                    button.classList.add('btn-' + category);
+                }
+            });
+        }
+        document.addEventListener('DOMContentLoaded', colorButtons);
+        new MutationObserver(colorButtons).observe(document.body, { childList: true, subtree: true });
+    </script>
+    """
+
+    st.markdown(css, unsafe_allow_html=True)
+    st.markdown(js, unsafe_allow_html=True)
+
+    # --- Keyboard Layout ---
+    layout = [
+        [
+            {"word": "I", "category": "pronoun"},
+            {"word": "am", "category": "verb"},
+            {"word": "how", "category": "question"},
+            {"word": "what", "category": "question"},
+            {"word": "when", "category": "question"},
+            {"word": "where", "category": "question"},
+            {"word": "who", "category": "question"},
+            {"word": "why", "category": "question"},
+            {"word": "That", "category": "pronoun"},
+            {"word": "Please", "category": "common"}
+        ],
+        [
+            {"word": "me", "category": "pronoun"},
+            {"word": "are", "category": "verb"},
+            {"word": "is", "category": "verb"},
+            {"word": "was", "category": "verb"},
+            {"word": "will", "category": "verb"},
+            {"word": "help", "category": "verb"},
+            {"word": "need", "category": "verb"},
+            {"word": "want", "category": "verb"},
+            {"word": "thank you", "category": "common"},
+            {"word": "sorry", "category": "common"}
+        ],
+        [
+            {"word": "my", "category": "pronoun"},
+            {"word": "can", "category": "verb"},
+            {"word": "A", "category": "misc"},
+            {"word": "B", "category": "misc"},
+            {"word": "C", "category": "misc"},
+            {"word": "D", "category": "misc"},
+            {"word": "E", "category": "misc"},
+            {"word": "F", "category": "misc"},
+            {"word": "G", "category": "misc"},
+            {"word": "H", "category": "misc"}
+        ],
+        [
+            {"word": "it", "category": "pronoun"},
+            {"word": "did", "category": "verb"},
+            {"word": "letter_I", "category": "misc", "display": "I"},
+            {"word": "J", "category": "misc"},
+            {"word": "K", "category": "misc"},
+            {"word": "L", "category": "misc"},
+            {"word": "M", "category": "misc"},
+            {"word": "N", "category": "misc"},
+            {"word": "O", "category": "misc"},
+            {"word": "P", "category": "misc"}
+        ],
+        [
+            {"word": "they", "category": "pronoun"},
+            {"word": "do", "category": "verb"},
+            {"word": "Q", "category": "misc"},
+            {"word": "R", "category": "misc"},
+            {"word": "S", "category": "misc"},
+            {"word": "T", "category": "misc"},
+            {"word": "U", "category": "misc"},
+            {"word": "V", "category": "misc"},
+            {"word": "W", "category": "misc"},
+            {"word": "X", "category": "misc"}
+        ],
+        [
+            {"word": "we", "category": "pronoun"},
+            {"word": "Y", "category": "misc"},
+            {"word": "Z", "category": "misc"},
+            {"word": "1", "category": "misc"},
+            {"word": "2", "category": "misc"},
+            {"word": "3", "category": "misc"},
+            {"word": "4", "category": "misc"},
+            {"word": "5", "category": "misc"},
+            {"word": ".", "category": "misc"},
+            {"word": "?", "category": "misc"}
+        ],
+        [
+            {"word": "you", "category": "pronoun"},
+            {"word": "6", "category": "misc"},
+            {"word": "7", "category": "misc"},
+            {"word": "8", "category": "misc"},
+            {"word": "9", "category": "misc"},
+            {"word": "0", "category": "misc"},
+            {"word": "-", "category": "misc"},
+            {"word": "!", "category": "misc"},
+            {"word": ",", "category": "misc"},
+            {"word": "SPACE", "category": "misc"}
+        ],
+        [
+            {"word": "your", "category": "pronoun"},
+            {"word": "like", "category": "verb"},
+            {"word": "to", "category": "preposition"},
+            {"word": "with", "category": "preposition"},
+            {"word": "in", "category": "preposition"},
+            {"word": "the", "category": "misc"},
+            {"word": "and", "category": "misc"},
+            {"word": "but", "category": "misc"},
+            {"word": "not", "category": "descriptive"},
+            {"word": "yes", "category": "common"}
+        ]
+    ]
+
+    # --- Add Custom Words ---
+    if st.session_state.custom_words:
+        custom_row = []
+        for idx, word_info in enumerate(st.session_state.custom_words):
+            word = word_info["word"]
+            category = word_info["category"]
+            custom_row.append({"word": f"custom_{idx}_{word}", "display": word, "category": category})
+            if len(custom_row) == 10:
+                layout.append(custom_row)
+                custom_row = []
+        if custom_row:
+            while len(custom_row) < 10:
+                custom_row.append({"word": "", "category": "misc"})
+            layout.append(custom_row)
+
+    # --- Initialize Assistant ---
+    # Attempt initialization only once or if it failed previously
+    if st.session_state.assistant is None: # This check is now safe
+        st.session_state.assistant = initialize_assistant(DEFAULT_DOCUMENT_PATH)
+
+    # --- Output Box (move to top, before keyboard) ---
+    st.title("Communication Board")
+    # Use st.text_area directly for input and display, bound to session state
+    st.session_state.text_output = st.text_area(
+        "Compose Message:", value=st.session_state.text_output, height=100, key="main_text_output"
+    )
+
+    # --- Keyboard Rendering (no delay, instant update) ---
+    send_action = False # Flag for SEND button
+    def add_to_output(word):
+        if word == "SPACE":
+            st.session_state.text_output += " "
+        elif word in [".", "?", "!", ",", "-"]:
+            st.session_state.text_output += word
+        elif word.isdigit() or (len(word) == 1 and word.isalpha()):
+            st.session_state.text_output += word
+        else:
+            if st.session_state.text_output and not st.session_state.text_output.endswith(" "):
+                st.session_state.text_output += " "
+            st.session_state.text_output += word
+
+    st.markdown("### Communication Keyboard")
+    for row_idx, row in enumerate(layout):
+        cols = st.columns(len(row))
+        for col_idx, item in enumerate(cols):
+            word_info = row[col_idx]
+            if "word" not in word_info or word_info["word"] == "":
+                continue
+            word = word_info["word"]
+            category = word_info["category"]
+            display = word_info.get("display", word)
+            key = f"key_{row_idx}_{col_idx}_{category}_{word}"
+            def make_callback(w=word, d=display):
+                def cb():
+                    if w.startswith("custom_") or w.startswith("letter_"):
+                        add_to_output(d)
+                    else:
+                        add_to_output(w)
+                return cb
+            with cols[col_idx]:
+                st.button(
+                    display if word != "SPACE" else "␣",
+                    key=key,
+                    on_click=make_callback()
+                )
+
+    # --- Control Buttons ---
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        if st.button("CLEAR", key="clear_btn", help="Clear all text", use_container_width=True, type="primary"):
+            st.session_state.text_output = ""
+            st.rerun() # Rerun to reflect change
+    with col2:
+        if st.button("SPEAK", key="speak_btn", help="Speak the current text", use_container_width=True, type="primary"):
+            if st.session_state.text_output:
+                st.toast(f"Speaking: {st.session_state.text_output}", icon="🔊")
+        if st.button("⌫ DEL", key="backspace", help="Delete last character", use_container_width=True):
+            if st.session_state.text_output:
+                st.session_state.text_output = st.session_state.text_output[:-1]
+    with col4:
+        if st.button("⌫ WORD", key="backspace_word", help="Delete last word", use_container_width=True):
+            if st.session_state.text_output:
+                words = st.session_state.text_output.rstrip().split()
+                if words:
+                    words.pop()
+                    st.session_state.text_output = " ".join(words)
+                    if words:
+                        st.session_state.text_output += " "
+    with col3: # Use the 3rd column for SEND
+        if st.button("SEND", key="send_btn", help="Send message to assistant", use_container_width=True, type="primary"):
+             if st.session_state.text_output:
+                 send_action = True # Set flag to process sending
+
+
+    # --- Settings Sidebar ---
+    with st.sidebar:
+        # --- Settings Section Commented Out ---
+        # st.title("Settings")
+        # st.subheader("Interface")
+        # theme_options = list(theme_colors.keys())
+        # theme_index = theme_options.index(st.session_state.theme)
+        # new_theme = st.selectbox("Theme", theme_options, index=theme_index)
+        # new_text_size = st.slider("Text Size", 12, 36, st.session_state.text_size)
+        # if st.button("Apply Settings Changes", type="primary"):
+        #     changed = False
+        #     if new_theme != st.session_state.theme:
+        #         st.session_state.theme = new_theme
+        #         changed = True
+        #     if new_text_size != st.session_state.text_size:
+        #         st.session_state.text_size = new_text_size
+        #         changed = True
+        #     if changed:
+        #         st.rerun()
+        # with st.expander("Speech Settings"):
+        #     speech_rate = st.slider("Rate", 0.5, 2.0, st.session_state.speech_rate, 0.1)
+        #     voice_options = ["Default Voice", "Female Voice", "Male Voice", "Child Voice"]
+        #     voice_index = voice_options.index(st.session_state.voice_option)
+        #     voice = st.selectbox("Voice", voice_options, index=voice_index)
+        #     if st.button("Apply Speech Settings"):
+        #         st.session_state.speech_rate = speech_rate
+        #         st.session_state.voice_option = voice
+        # st.subheader("Custom Words")
+        # with st.expander("Add New Word"):
+        #     word = st.text_input("Word")
+        #     cat = st.selectbox("Category", list(colors.keys()))
+        #     col1, col2 = st.columns(2)
+        #     with col1:
+        #         if st.button("Add", key="add_word"):
+        #             if word and cat:
+        #                 st.session_state.custom_words.append({"word": word, "category": cat})
+        #                 st.success(f"Added '{word}'")
+        #                 st.rerun()
+        #     if st.session_state.custom_words:
+        #         st.write("Current custom words:")
+        #         words_df = pd.DataFrame([
+        #             {"Word": w["word"], "Category": w["category"]}
+        #             for w in st.session_state.custom_words
+        #         ])
+        #         st.dataframe(words_df, hide_index=True)
+        #         with col2:
+        #             if st.button("Clear All", key="clear_words"):
+        #                 st.session_state.custom_words = []
+        #                 st.success("Words cleared")
+        #                 st.rerun()
+        # --- End of Settings Section Commented Out ---
+
+        st.divider()
+        # --- Chat History Display in Sidebar ---
+        st.subheader("Conversation")
+        chat_container = st.container(height=400) # Fixed height container
+        with chat_container:
+            for message in st.session_state.messages:
+                with st.chat_message(message["role"]):
+                    st.markdown(message["content"])
+
+    # --- Process SEND Action ---
+    if send_action and st.session_state.assistant:
+        user_message = st.session_state.text_output
+        st.session_state.messages.append({"role": "user", "content": user_message})
+
+        # Process with AACAssistant
+        try:
+            # Get the response from the AACAssistant
+            response = st.session_state.assistant.process_query(user_message)
+            # Add assistant response to chat history
+            st.session_state.messages.append({"role": "assistant", "content": response})
+        except Exception as e:
+            error_message = f"An error occurred: {e}"
+            st.error(error_message) # Show error in main area
+            st.session_state.messages.append({"role": "assistant", "content": f"*Error processing: {error_message}*"})
+
+        # Clear the board's text area after sending
+        st.session_state.text_output = ""
+        st.rerun() # Rerun to update chat and clear board
+
+if __name__ == "__main__":
+    main()

rag.py

@@ -0,0 +1,341 @@
+# /Users/divyeshpatel/Desktop/archiveWork/rajvi/nlp/rag.py
+# !pip install llama-cpp-python
+
+# from llama.cpp import Llama
+#
+# llm = Llama.from_pretrained(
+# 	repo_id="rdz-falcon/model",
+# 	filename="unsloth.F16.gguf",
+# )
+
+# !pip install langchain
+# !pip install langchain-community
+
+# !pip install chromadb
+
+import os
+import torch
+import tempfile
+from langchain.chains import ConversationalRetrievalChain
+from langchain.memory import ConversationBufferMemory
+from langchain_community.document_loaders import TextLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import Chroma
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain_community.llms import HuggingFacePipeline
+from langchain.prompts import PromptTemplate
+from langchain_community.llms import Ollama 
+from langchain_openai import ChatOpenAI
+from transformers import AutoTokenizer, pipeline, AutoModelForCausalLM, BitsAndBytesConfig
+
+def setup_document_retriever(document_path):
+    # Load documents with the AAC user's personal experiences
+    loader = TextLoader(document_path)
+    documents = loader.load()
+
+    # Split documents into chunks
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000,
+        chunk_overlap=200,
+        separators=["\n\n", "\n", " ", ""]
+    )
+    chunks = text_splitter.split_documents(documents)
+
+    # Create embeddings
+    embeddings = HuggingFaceEmbeddings(
+        model_name="sentence-transformers/all-MiniLM-L6-v2",
+        model_kwargs={'device': 'cuda' if torch.cuda.is_available() else 'cpu'}
+    )
+
+    # Create a persistent directory for the ChromaDB
+    persist_directory = os.path.join(tempfile.gettempdir(), "chroma_db")
+
+    # Create Chroma vector store
+    vectorstore = Chroma.from_documents(
+        documents=chunks,
+        embedding=embeddings,
+        persist_directory=persist_directory
+    )
+
+    # Persist the database to disk
+    vectorstore.persist()
+
+    return vectorstore
+
+def load_emotion_classifier(api_base_url="http://127.0.0.1:1234/v1"):
+    """
+    This function configures and returns a LangChain LLM client
+    to interact with an OpenAI-compatible API endpoint (like LM Studio).
+
+    Args:
+        api_base_url (str): The base URL of the OpenAI-compatible API endpoint.
+
+    Returns:
+        ChatOpenAI: A LangChain ChatOpenAI instance configured for the API.
+    """
+    print(f"=== CONFIGURING LLM CLIENT FOR API: {api_base_url} ===")
+
+    
+    llm = ChatOpenAI(
+        openai_api_base=api_base_url,
+        openai_api_key="dummy-key", # Required by LangChain, but not used by LM Studio
+        temperature=0.7,
+        max_tokens=128,
+    )
+    return llm
+
+    # --- The following code was commented out or unreachable in the original notebook ---
+    # Example code (replace with appropriate code for your model):
+    # tokenizer = AutoTokenizer.from_pretrained(model_name)
+    # model = AutoModelForCausalLM.from_pretrained(model_name)
+    # emotion_pipeline = pipeline("text-generation", model=model, tokenizer=tokenizer)
+
+    # input_emotion = "excited"
+    # input_situation = text # 'text' variable was not defined here in the original notebook
+
+    #     # Format the user message content
+    # user_content = f"Emotion: {input_emotion}\nSituation: {input_situation}"
+    #   # Create the messages list in the standard OpenAI/chat format
+    # messages = [
+    #         # Note: llama-cpp might not explicitly use a system prompt unless provided here
+    #         # or baked into the chat_format handler. You might need to add:
+    #         # {"role": "system", "content": "You are an empathetic assistant."},
+    #         {"role": "user", "content": user_content},
+    #     ]
+
+    #     # --- 3. Generate the response using create_chat_completion -- This method doesn't exist on ChatOpenAI, use invoke instead ---
+    # print("Generating response...")
+    # try:
+    #     response = llm.create_chat_completion( # This should be llm.invoke(messages)
+    #     messages=messages,
+    #     max_tokens=128,       # Max length of the generated response (adjust as needed)
+    #     temperature=0.7,    # Controls randomness (adjust)
+    #     # top_p=0.9,          # Optional: Nucleus sampling
+    #     # top_k=40,           # Optional: Top-k sampling
+    #     stop=["<|eot_id|>"], # Crucial: Stop generation when the model outputs the end-of-turn token
+    #     stream=False,        # Set to True to get token-by-token output (like TextStreamer)
+    #     )
+
+    #         # --- 4. Extract and print the response -- Access response.content with invoke ---
+    #     if response and 'choices' in response and len(response['choices']) > 0:
+    #           assistant_message = response['choices'][0]['message']['content']
+    #           print("\nAssistant Response:")
+    #           print(assistant_message.strip())
+    #           print("returning:", assistant_message.strip())
+    #           return assistant_message.strip()
+    #     else:
+    #           print("\nNo response generated or unexpected format.")
+    #           print("Full response:", response)
+
+    #           return ""
+
+    # except Exception as e:
+    #     print(f"\nAn error occurred during generation: {e}")
+    #     return ""
+    # --- End of commented out/unreachable code ---
+
+
+def load_generation_model():
+    """Load the specified Ollama model using LangChain."""
+    print("=== CONFIGURING OLLAMA GENERATION MODEL ===")
+    model_name = "llama3.2" # Your desired Ollama model
+
+    # Instantiate the Ollama LLM
+    try:
+        generation_llm = Ollama(
+            model=model_name,
+            # temperature=0.1
+        )
+        print(f"Ollama model '{model_name}' configured.")
+    except Exception as e:
+        print(f"Error configuring Ollama model: {e}")
+        print("Please ensure the Ollama server is running and the model is available.")
+        raise
+
+    return generation_llm
+
+def create_prompt_templates():
+    """Create prompt templates for the assistant"""
+
+    template = """
+<|system|>
+You are an AAC (Augmentative and Alternative Communication) user (Elliot) engaging in a conversation. Your responses must reflect factual details provided in your personal context, be empathetic as guided by the emotion analysis, and align naturally with your previous chat history. You will respond directly as the AAC user, speaking in the first person (using "I", "my", "me").
+
+**Instructions:**
+1. Understand the question asked by the conversation partner.
+2. Use the provided "Context" to include accurate personal details about your life (Elliot).
+3. Reflect the empathetic tone described in the "Empathetic Response Guidance".
+4. Ensure your response fits logically within the "Chat History".
+5. Keep your response concise, empathetic, and natural.
+6. Ignore the empathetic tone described in the "Empathetic Response Guidance" if it is not related to the conversation.
+
+**Context:**
+{context}
+
+**Chat History:**
+{chat_history}
+
+**Empathetic Response Guidance:**
+{emotion_analysis}</s>
+<|user|>
+The conversation partner asked: "{question}"
+
+Please generate your response as the AAC user, following the instructions above.</s>
+<|assistant|>
+
+    """.strip()
+
+    PROMPT = PromptTemplate(
+        input_variables=["question", "emotion_analysis", "context", "chat_history"],
+        template=template,
+    )
+    print("\n Prompt:", PROMPT)
+    return PROMPT
+
+class AACAssistant:
+    def __init__(self, document_path):
+        print("Initializing AAC Assistant...")
+        print("Loading document retriever...")
+        self.vectorstore = setup_document_retriever(document_path)
+        print("Configuring emotion LLM client...")
+        # Use the new function to get the client for the API
+        self.emotion_llm = load_emotion_classifier() # You can pass a different URL if needed
+        print("Loading generation model...")
+        self.llm = load_generation_model() # This now loads the Ollama model
+        print("Creating prompt templates...")
+        self.prompt = create_prompt_templates()
+        print("Setting up conversation memory...")
+
+        # Set up memory for chat history
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True,
+            output_key="answer",
+            # Specify the input key for the memory explicitly
+            input_key="question"
+        )
+
+        # Create retrieval chain (using the main generation LLM)
+        self.chain = ConversationalRetrievalChain.from_llm(
+            llm=self.llm, # Use the main generation model here
+            retriever=self.vectorstore.as_retriever(search_kwargs={'k': 3}),
+            memory=self.memory,
+            combine_docs_chain_kwargs={"prompt": self.prompt},
+            return_source_documents=True,
+            verbose=True
+        )
+
+        print("AAC Assistant initialized and ready!")
+
+    def get_emotion_analysis(self, situation):
+        """
+        Gets emotion analysis from the configured emotion LLM API.
+        """
+        # Define the prompt structure for the emotion analysis model
+        # (Adjust this based on how you prompted your model in LM Studio)
+        input_emotion = "excited" # Or determine this dynamically if needed
+        user_content = f"Emotion: {input_emotion}\nSituation: {situation}\nGenerate a brief analysis of the user's likely feeling based on the situation."
+
+        messages = [
+            # {"role": "system", "content": "You are an empathetic assistant analyzing emotions."},
+            {"role": "user", "content": user_content},
+        ]
+
+        print(f"Sending to emotion API: {messages}")
+        try:
+            # Use the invoke method for ChatOpenAI
+            response = self.emotion_llm.invoke(messages)
+            # The response object has a 'content' attribute
+            analysis = response.content.strip()
+            print(f"Received from emotion API: {analysis}")
+            return analysis
+        except Exception as e:
+            print(f"\nAn error occurred during emotion analysis API call: {e}")
+            # Fallback or default analysis
+            return f"Could not determine emotion (API error: {e})"
+
+
+    def process_query(self, user_query):
+        """
+        Process a query from the conversation partner to the AAC user.
+
+        Args:
+            user_query (str): Question asked by the conversation partner
+
+        Returns:
+            str: Generated response for the AAC user to communicate
+        """
+        # Step 1: Get emotion analysis from the LM Studio API via the emotion_llm client
+        print(f"Getting emotion analysis for query: '{user_query}'")
+        emotion_analysis = self.get_emotion_analysis(user_query)
+        print(f"Emotion Analysis Result: {emotion_analysis}")
+
+        # Step 2: Run the RAG + LLM chain (using the main generation model)
+        # The emotion_analysis is now passed into the prompt context
+        print("Running main RAG chain...")
+        # Use invoke instead of the deprecated __call__
+        # Pass inputs as a dictionary matching the chain's expected input keys
+        response = self.chain.invoke(
+            {"question": user_query, "emotion_analysis": emotion_analysis}
+        )
+
+        return response["answer"]
+
+# def run_demo():
+#     # Sample personal experiences document path - replace with your actual file
+#     document_path = "aac_user_experiences.txt"
+
+#     # Create a dummy document if it doesn't exist for demonstration
+#     # if not os.path.exists(document_path):
+#     #     with open(document_path, "w") as f:
+#     #         f.write("""
+#     #         I grew up in Seattle and love the rain.
+#     #         My favorite hobby is playing chess, which I've been doing since I was 7 years old.
+#     #         I have a dog named Max who is a golden retriever.
+#     #         I went to college at University of Washington and studied computer science.
+#     #         I enjoy watching sci-fi movies and Star Trek is my favorite series.
+#     #         I've traveled to Japan twice and love Japanese cuisine.
+#     #         Music helps me relax, especially classical piano pieces.
+#     #         I volunteer at the local animal shelter once a month.
+#     #         """)
+
+#     # Initialize the assistant
+#     assistant = AACAssistant(document_path)
+
+#     # Interactive demo
+#     print("\n===== AAC Communication Assistant Demo =====")
+#     print("(Type 'exit' to end the demo)")
+
+#     while True:
+#         try:
+#             user_input = input("\nConversation partner says: ")
+#             if user_input.lower() == 'exit':
+#                 break
+
+#             response = assistant.process_query(user_input)
+#             print(f"\nAAC user communicates: {response}")
+#         except EOFError: # Handle case where input stream ends unexpectedly
+#             print("\nInput stream closed. Exiting demo.")
+#             break
+#         except KeyboardInterrupt: # Handle Ctrl+C
+#             print("\nDemo interrupted by user. Exiting.")
+#             break
+#         except Exception as e:
+#             print(f"\nAn unexpected error occurred: {e}")
+#             # Optionally add more specific error handling or logging
+#             # Consider whether to break or continue the loop on error
+#             break # Exit on error for safety
+
+# try:
+#     from importlib.metadata import PackageNotFoundError
+# except ImportError:
+#     # Define a fallback for older Python versions
+#     class PackageNotFoundError(Exception):
+#         pass
+
+# # Cell 13: Main Execution Block
+# if __name__ == "__main__":
+#     run_demo()
+
+# # !pip install bitsandbytes -q || echo "bitsandbytes installation failed, will use fp16 precision instead"
+# # pip install -U bitsandbytes