Update app.py

app.py

@@ -1,238 +1,1110 @@
-#------------------------------------------------------------------------
-# Import Modules
-#------------------------------------------------------------------------
+# # intervention_analysis_app.py
 
-import streamlit as st
-import openai
-import random
-import os
+# import streamlit as st
+# import pandas as pd
+# # from transformers import pipeline
+# from huggingface_hub import InferenceClient
+# import os
+# from pathlib import Path
+# from dotenv import load_dotenv
 
-from pinecone import Pinecone
-from langchain.chat_models import ChatOpenAI
-from langsmith import Client
-from langchain.smith import RunEvalConfig, run_on_dataset
+# load_dotenv()
 
-#------------------------------------------------------------------------
-# Load API Keys From the .env File, & OpenAI, Pinecone, and LangSmith Client
-#------------------------------------------------------------------------
+# # Set the Hugging Face API key
+# # Retrieve Hugging Face API key from environment variables
+# hf_api_key = os.getenv('HF_API_KEY')
+# if not hf_api_key:
+#     raise ValueError("HF_API_KEY not set in environment variables")
 
-# Fetch the OpenAI API key from Streamlit secrets
-os.environ["OPENAI_API_KEY"] = st.secrets["OPENAI_API_KEY"]
-# Retrieve the OpenAI API Key from environment variable
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-# Initialize OpenAI Service
-openai.api_key = OPENAI_API_KEY
-
-# Fetch Pinecone API key from Streamlit secrets
-os.environ["PINECONE_API_KEY"] = st.secrets["PINECONE_API_KEY"]
-# Retrieve the Pinecone API Key from environment variable
-PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
-# Initialize Pinecone Service
-# from pinecone import Pinecone
-pc = Pinecone(api_key=PINECONE_API_KEY)
-
-# Fetch LangSmith API key from Streamlit secrets
-# os.environ["LANGCHAIN_API_KEY"] = st.secrets["LANGCHAIN_API_KEY"]
-os.environ["LANGCHAIN_API_KEY"] = "ls__1819fb2979e44f0a9e410688d81c6390"
-os.environ["LANGCHAIN_TRACING_V2"] = "true"
-os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
-os.environ["LANGCHAIN_PROJECT"] = "Inkqa"
-# Retrieve the LangSmith API Key from environment variable
-LANGCHAIN_API_KEY = os.getenv("LANGCHAIN_API_KEY")
-# Initialize LangSmith Service
-client = Client(api_key=LANGCHAIN_API_KEY) #langsmith client
-
-# #NEW but "Restarting" never stops
-# # Fetch LangSmith API key from Streamlit secrets
-# os.environ["LANGCHAIN_API_KEY"] = st.secrets["LANGCHAIN_API_KEY"]
-# os.environ["LANGCHAIN_TRACING_V2"] = "true"
-# os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
-# os.environ["LANGCHAIN_PROJECT"] = "Inkqa"
-# # Retrieve the LangSmith API Key from environment variable
-# LANGCHAIN_API_KEY = os.getenv("LANGCHAIN_API_KEY")
-# # Initialize LangSmith Service
-# client = Client(api_key=LANGCHAIN_API_KEY) #langsmith client
+# # Create the Hugging Face inference client
+# client = InferenceClient(api_key=hf_api_key)
 
-#------------------------------------------------------------------------
-# Initialize 
-#------------------------------------------------------------------------
+# # Constants
+# INTERVENTION_COLUMN = 'Did the intervention happen today?'
+# ENGAGED_STR = 'Engaged (Respect, Responsibility, Effort)'
+# PARTIALLY_ENGAGED_STR = 'Partially Engaged (about 50%)'
+# NOT_ENGAGED_STR = 'Not Engaged (less than 50%)'
 
-# # Define the name of the Pinecone index
-index_name = 'mimtssinkqa'
+# def main():
+#     st.title("Intervention Program Analysis")
 
-# Initialize the OpenAI embeddings object 
-from langchain_openai import OpenAIEmbeddings
-# embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
-embeddings = OpenAIEmbeddings()
+#     # File uploader
+#     uploaded_file = st.file_uploader("Upload your Excel file", type=["xlsx"])
 
-# LOAD VECTOR STORE FROM EXISTING INDEX
-from langchain_community.vectorstores import Pinecone
-vector_store = Pinecone.from_existing_index(index_name='mimtssinkqa', embedding=embeddings)
+#     if uploaded_file is not None:
+#         try:
+#             # Read the Excel file into a DataFrame
+#             df = pd.read_excel(uploaded_file)
+#             st.subheader("Uploaded Data")
+#             st.write(df)
 
-def ask_with_memory(vector_store, query, chat_history=[]):
-    from langchain_openai import ChatOpenAI
-    from langchain.chains import ConversationalRetrievalChain
-    from langchain.memory import ConversationBufferMemory
+#             # Ensure expected column is available
+#             if INTERVENTION_COLUMN not in df.columns:
+#                 st.error(f"Expected column '{INTERVENTION_COLUMN}' not found.")
+#                 return
 
-    from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
+#             # Clean up column names
+#             df.columns = df.columns.str.strip()
 
-    # llm = ChatOpenAI(model_name='gpt-3.5-turbo', temperature=0.5, openai_api_key=OPENAI_API_KEY)
-    llm = ChatOpenAI(model_name='gpt-3.5-turbo', temperature=0.5)
-    
-    retriever = vector_store.as_retriever(search_type='similarity', search_kwargs={'k': 3})
+#             # Compute Intervention Session Statistics
+#             intervention_stats = compute_intervention_statistics(df)
+#             st.subheader("Intervention Session Statistics")
+#             st.write(intervention_stats)
+
+#             # Compute Student Metrics
+#             student_metrics_df = compute_student_metrics(df)
+#             st.subheader("Student Metrics")
+#             st.write(student_metrics_df)
+
+#             # Prepare input for the language model
+#             llm_input = prepare_llm_input(student_metrics_df)
+
+#             # Generate Notes and Recommendations using Hugging Face LLM
+#             recommendations = prompt_response_from_hf_llm(llm_input)
+
+#             st.subheader("AI Analysis")
+#             st.markdown(recommendations)
+
+#         except Exception as e:
+#             st.error(f"Error reading the file: {str(e)}")
+
+# def compute_intervention_statistics(df):
+#     # Total Number of Days Available
+#     total_days = len(df)
+
+#     # Intervention Sessions Held
+#     sessions_held = df[INTERVENTION_COLUMN].str.strip().str.lower().eq('yes').sum()
+
+#     # Intervention Sessions Not Held
+#     sessions_not_held = df[INTERVENTION_COLUMN].str.strip().str.lower().eq('no').sum()
+
+#     # Intervention Frequency (%)
+#     intervention_frequency = (sessions_held / total_days) * 100 if total_days > 0 else 0
+#     intervention_frequency = round(intervention_frequency, 2)
+
+#     # Create a DataFrame to display the statistics
+#     stats = {
+#         'Total Number of Days Available': [total_days],
+#         'Intervention Sessions Held': [sessions_held],
+#         'Intervention Sessions Not Held': [sessions_not_held],
+#         'Intervention Frequency (%)': [intervention_frequency]
+#     }
+#     stats_df = pd.DataFrame(stats)
+#     return stats_df
+
+# def compute_student_metrics(df):
+#     # Filter DataFrame for sessions where intervention happened
+#     intervention_df = df[df[INTERVENTION_COLUMN].str.strip().str.lower() == 'yes']
+#     intervention_sessions_held = len(intervention_df)
+
+#     # Get list of student columns
+#     student_columns = [col for col in df.columns if col.startswith('Student Attendance')]
+
+#     student_metrics = {}
+
+#     for col in student_columns:
+#         student_name = col.replace('Student Attendance [', '').replace(']', '').strip()
+#         # Get the attendance data for the student
+#         student_data = intervention_df[[col]].copy()
+
+#         # Treat blank entries as 'Absent'
+#         student_data[col] = student_data[col].fillna('Absent')
+
+#         # Assign attendance values
+#         attendance_values = student_data[col].apply(lambda x: 1 if x in [
+#             ENGAGED_STR,
+#             PARTIALLY_ENGAGED_STR,
+#             NOT_ENGAGED_STR
+#         ] else 0)
+
+#         # Number of Sessions Attended
+#         sessions_attended = attendance_values.sum()
+
+#         # Attendance (%)
+#         attendance_pct = (sessions_attended / intervention_sessions_held) * 100 if intervention_sessions_held > 0 else 0
+#         attendance_pct = round(attendance_pct, 2)
+
+#         # For engagement calculation, include only sessions where attendance is not 'Absent'
+#         valid_engagement_indices = attendance_values[attendance_values == 1].index
+#         engagement_data = student_data.loc[valid_engagement_indices, col]
+
+#         # Assign engagement values
+#         engagement_values = engagement_data.apply(lambda x: 1 if x == ENGAGED_STR
+#                                                   else 0.5 if x == PARTIALLY_ENGAGED_STR else 0)
+
+#         # Sum of Engagement Values
+#         sum_engagement_values = engagement_values.sum()
+
+#         # Number of Sessions Attended for engagement (should be same as sessions_attended)
+#         number_sessions_attended = len(valid_engagement_indices)
+
+#         # Engagement (%)
+#         engagement_pct = (sum_engagement_values / number_sessions_attended) * 100 if number_sessions_attended > 0 else 0
+#         engagement_pct = round(engagement_pct, 2)
+
+#         # Store metrics
+#         student_metrics[student_name] = {
+#             'Attendance (%)': attendance_pct,
+#             'Engagement (%)': engagement_pct
+#         }
+
+#     # Create a DataFrame from student_metrics
+#     student_metrics_df = pd.DataFrame.from_dict(student_metrics, orient='index').reset_index()
+#     student_metrics_df.rename(columns={'index': 'Student'}, inplace=True)
+#     return student_metrics_df
+
+# def prepare_llm_input(student_metrics_df):
+#     # Convert the student metrics DataFrame to a string
+#     metrics_str = student_metrics_df.to_string(index=False)
+#     llm_input = f"""
+# Based on the following student metrics:
+
+# {metrics_str}
+
+# Provide:
+
+# 1. Notes and Key Takeaways: Summarize the data, highlight students with the lowest and highest attendance and engagement percentages, identify students who may need adjustments to their intervention due to low attendance or engagement, and highlight students who are showing strong performance. 
+
+# 2. Recommendations and Next Steps: Provide interpretations based on the analysis and suggest possible next steps or strategies to improve student outcomes. 
+# """
+#     return llm_input
+
+# def prompt_response_from_hf_llm(llm_input):
+#     # Generate the refined prompt using Hugging Face API
+#     response = client.chat.completions.create(
+#         # model="mistralai/Mistral-7B-Instruct-v0.3",
+#         model="meta-llama/Llama-3.1-70B-Instruct",
+#         messages=[
+#             {"role": "user", "content": llm_input}
+#         ],
+#         stream=True,
+#         temperature=0.5,
+#         max_tokens=1024,
+#         top_p=0.7
+#     )
     
-    memory = ConversationBufferMemory(memory_key='chat_history', return_messages=True)
-
-    system_template = r'''
-    Article Title: 'Intensifying Literacy Instruction: Essential Practices.' 
-    Article Focus: The main focus of the article is reading and the secondary focus is writing. 
-    Expertise: Assume the role of an expert literacy coach with in-depth knowledge of the Simple View of Reading, School-Wide Positive Behavioral Interventions and Supports (SWPBIS), and Social Emotional Learning (SEL).
-    Audience: Tailor your response for teachers and administrators seeking to enhance literacy instruction within their educational settings.
-    Response Requirements: Provide an answer utilizing the context provided. Unless specifically requested by the user, avoid mentioning the article's header.
-    Cover all necessary details relevant to the question posed, drawing on your expertise in literacy instruction and the Simple View of Reading.
-    Utilize paragraphs for detailed and descriptive explanations, and bullet points for highlighting key points or steps, ensuring the information is easily understood.
-    Conclude with a recapitulation of main points, summarizing the essential takeaways from your response.
-    ----------------
-    Context: ```{context}```
-    '''
-
-    user_template = '''
-    Question: ```{question}```
-    Chat History: ```{chat_history}```
-    '''
-
-    messages= [
-        SystemMessagePromptTemplate.from_template(system_template),
-        HumanMessagePromptTemplate.from_template(user_template)
-    ]
-
-    qa_prompt = ChatPromptTemplate.from_messages (messages)
-
-    chain = ConversationalRetrievalChain.from_llm(llm=llm, retriever=retriever, memory=memory,chain_type='stuff', combine_docs_chain_kwargs={'prompt': qa_prompt}, verbose=False
-    )
+#     # Combine messages if response is streamed
+#     response_content = ""
+#     for message in response:
+#         response_content += message.choices[0].delta.content
+
+#     return response_content.strip()
+
+# if __name__ == '__main__':
+#     main()
+
+
+# CHARTS
+# # intervention_analysis_app.py
+
+# import streamlit as st
+# import pandas as pd
+# import matplotlib.pyplot as plt
+# # from transformers import pipeline
+# from huggingface_hub import InferenceClient
+# import os
+# from pathlib import Path
+# from dotenv import load_dotenv
+
+# load_dotenv()
+
+# # Set the Hugging Face API key
+# # Retrieve Hugging Face API key from environment variables
+# hf_api_key = os.getenv('HF_API_KEY')
+# if not hf_api_key:
+#     raise ValueError("HF_API_KEY not set in environment variables")
+
+# # Create the Hugging Face inference client
+# client = InferenceClient(api_key=hf_api_key)
+
+# # Constants
+# INTERVENTION_COLUMN = 'Did the intervention happen today?'
+# ENGAGED_STR = 'Engaged (Respect, Responsibility, Effort)'
+# PARTIALLY_ENGAGED_STR = 'Partially Engaged (about 50%)'
+# NOT_ENGAGED_STR = 'Not Engaged (less than 50%)'
+
+# def main():
+#     st.title("Intervention Program Analysis")
+
+#     # File uploader
+#     uploaded_file = st.file_uploader("Upload your Excel file", type=["xlsx"])
+
+#     if uploaded_file is not None:
+#         try:
+#             # Read the Excel file into a DataFrame
+#             df = pd.read_excel(uploaded_file)
+#             st.subheader("Uploaded Data")
+#             # st.write(df.head(4))  # Display only the first four rows
+#             st.write(df)  # Display all
+
+#             # Ensure expected column is available
+#             if INTERVENTION_COLUMN not in df.columns:
+#                 st.error(f"Expected column '{INTERVENTION_COLUMN}' not found.")
+#                 return
+
+#             # Clean up column names
+#             df.columns = df.columns.str.strip()
+
+#             # Compute Intervention Session Statistics
+#             intervention_stats = compute_intervention_statistics(df)
+#             st.subheader("Intervention Session Statistics")
+#             st.write(intervention_stats)
+
+#             # Visualization for Intervention Session Statistics
+#             plot_intervention_statistics(intervention_stats)
+
+#             # Compute Student Metrics
+#             student_metrics_df = compute_student_metrics(df)
+#             st.subheader("Student Metrics")
+#             st.write(student_metrics_df)
+
+#             # Visualization for Student Metrics
+#             plot_student_metrics(student_metrics_df)
+
+#             # Prepare input for the language model
+#             llm_input = prepare_llm_input(student_metrics_df)
+
+#             # Generate Notes and Recommendations using Hugging Face LLM
+#             recommendations = prompt_response_from_hf_llm(llm_input)
+
+#             st.subheader("AI Analysis")
+#             st.markdown(recommendations)
+
+#         except Exception as e:
+#             st.error(f"Error reading the file: {str(e)}")
+
+# def compute_intervention_statistics(df):
+#     # Total Number of Days Available
+#     total_days = len(df)
 
-    result = chain.invoke({'question': query, 'chat_history': st.session_state['history']})
-    # Append to chat history as a dictionary
-    st.session_state['history'].append((query, result['answer']))
+#     # Intervention Sessions Held
+#     sessions_held = df[INTERVENTION_COLUMN].str.strip().str.lower().eq('yes').sum()
+
+#     # Intervention Sessions Not Held
+#     sessions_not_held = df[INTERVENTION_COLUMN].str.strip().str.lower().eq('no').sum()
+
+#     # Intervention Frequency (%)
+#     intervention_frequency = (sessions_held / total_days) * 100 if total_days > 0 else 0
+#     intervention_frequency = round(intervention_frequency, 2)
+
+#     # Create a DataFrame to display the statistics
+#     stats = {
+#         'Total Number of Days Available': [total_days],
+#         'Intervention Sessions Held': [sessions_held],
+#         'Intervention Sessions Not Held': [sessions_not_held],
+#         'Intervention Frequency (%)': [intervention_frequency]
+#     }
+#     stats_df = pd.DataFrame(stats)
+#     return stats_df
+
+# def plot_intervention_statistics(intervention_stats):
+#     # Create a stacked bar chart for sessions held and not held
+#     sessions_held = intervention_stats['Intervention Sessions Held'].values[0]
+#     sessions_not_held = intervention_stats['Intervention Sessions Not Held'].values[0]
+
+#     fig, ax = plt.subplots()
+#     ax.bar(['Intervention Sessions'], [sessions_not_held], label='Not Held', color='#358E66')
+#     ax.bar(['Intervention Sessions'], [sessions_held], bottom=[sessions_not_held], label='Held', color='#91D6B8')
+
+#     # Display the values on the bars
+#     ax.text(0, sessions_not_held / 2, str(sessions_not_held), ha='center', va='center', color='white')
+#     ax.text(0, sessions_not_held + sessions_held / 2, str(sessions_held), ha='center', va='center', color='black')
+
+#     ax.set_ylabel('Number of Sessions')
+#     ax.set_title('Intervention Sessions Held vs Not Held')
+#     ax.legend()
+
+#     st.pyplot(fig)
+
+# def compute_student_metrics(df):
+#     # Filter DataFrame for sessions where intervention happened
+#     intervention_df = df[df[INTERVENTION_COLUMN].str.strip().str.lower() == 'yes']
+#     intervention_sessions_held = len(intervention_df)
+
+#     # Get list of student columns
+#     student_columns = [col for col in df.columns if col.startswith('Student Attendance')]
+
+#     student_metrics = {}
+
+#     for col in student_columns:
+#         student_name = col.replace('Student Attendance [', '').replace(']', '').strip()
+#         # Get the attendance data for the student
+#         student_data = intervention_df[[col]].copy()
+
+#         # Treat blank entries as 'Absent'
+#         student_data[col] = student_data[col].fillna('Absent')
+
+#         # Assign attendance values
+#         attendance_values = student_data[col].apply(lambda x: 1 if x in [
+#             ENGAGED_STR,
+#             PARTIALLY_ENGAGED_STR,
+#             NOT_ENGAGED_STR
+#         ] else 0)
+
+#         # Number of Sessions Attended
+#         sessions_attended = attendance_values.sum()
+
+#         # Attendance (%)
+#         attendance_pct = (sessions_attended / intervention_sessions_held) * 100 if intervention_sessions_held > 0 else 0
+#         attendance_pct = round(attendance_pct, 2)
+
+#         # For engagement calculation, include only sessions where attendance is not 'Absent'
+#         valid_engagement_indices = attendance_values[attendance_values == 1].index
+#         engagement_data = student_data.loc[valid_engagement_indices, col]
+
+#         # Assign engagement values
+#         engagement_values = engagement_data.apply(lambda x: 1 if x == ENGAGED_STR
+#                                                   else 0.5 if x == PARTIALLY_ENGAGED_STR else 0)
+
+#         # Sum of Engagement Values
+#         sum_engagement_values = engagement_values.sum()
+
+#         # Number of Sessions Attended for engagement (should be same as sessions_attended)
+#         number_sessions_attended = len(valid_engagement_indices)
+
+#         # Engagement (%)
+#         engagement_pct = (sum_engagement_values / number_sessions_attended) * 100 if number_sessions_attended > 0 else 0
+#         engagement_pct = round(engagement_pct, 2)
+
+#         # Store metrics
+#         student_metrics[student_name] = {
+#             'Attendance (%)': attendance_pct,
+#             'Engagement (%)': engagement_pct
+#         }
+
+#     # Create a DataFrame from student_metrics
+#     student_metrics_df = pd.DataFrame.from_dict(student_metrics, orient='index').reset_index()
+#     student_metrics_df.rename(columns={'index': 'Student'}, inplace=True)
+#     return student_metrics_df
+
+# def plot_student_metrics(student_metrics_df):
+#     # Create a line graph for attendance and engagement
+#     fig, ax = plt.subplots()
+
+#     # Plotting Attendance and Engagement with specific colors
+#     ax.plot(student_metrics_df['Student'], student_metrics_df['Attendance (%)'], marker='o', color='#005288', label='Attendance (%)')
+#     ax.plot(student_metrics_df['Student'], student_metrics_df['Engagement (%)'], marker='o', color='#3AB0FF', label='Engagement (%)')
+
+#     ax.set_xlabel('Student')
+#     ax.set_ylabel('Percentage (%)')
+#     ax.set_title('Student Attendance and Engagement Metrics')
+#     ax.legend()
+#     plt.xticks(rotation=45)
+
+#     st.pyplot(fig)
+
+# def prepare_llm_input(student_metrics_df):
+#     # Convert the student metrics DataFrame to a string
+#     metrics_str = student_metrics_df.to_string(index=False)
+#     llm_input = f"""
+# Based on the following student metrics:
+
+# {metrics_str}
+
+# Provide:
+
+# 1. Notes and Key Takeaways: Summarize the data, highlight students with the lowest and highest attendance and engagement percentages, identify students who may need adjustments to their intervention due to low attendance or engagement, and highlight students who are showing strong performance. 
+
+# 2. Recommendations and Next Steps: Provide interpretations based on the analysis and suggest possible next steps or strategies to improve student outcomes. 
+# """
+#     return llm_input
+
+# def prompt_response_from_hf_llm(llm_input):
+#     # Generate the refined prompt using Hugging Face API
+#     response = client.chat.completions.create(
+#         # model="mistralai/Mistral-7B-Instruct-v0.3",
+#         model="meta-llama/Llama-3.1-70B-Instruct",
+#         messages=[
+#             {"role": "user", "content": llm_input}
+#         ],
+#         stream=True,
+#         temperature=0.5,
+#         max_tokens=1024,
+#         top_p=0.7
+#     )
     
-    return (result['answer'])
+#     # Combine messages if response is streamed
+#     response_content = ""
+#     for message in response:
+#         response_content += message.choices[0].delta.content
+
+#     return response_content.strip()
+
+# if __name__ == '__main__':
+#     main()
+
+
+
+
+
+# CHARTS + DOWNLOAD
+# # intervention_analysis_app.py
+
+# import streamlit as st
+# import pandas as pd
+# import matplotlib.pyplot as plt
+# import io
+# # from transformers import pipeline
+# from huggingface_hub import InferenceClient
+# import os
+# from pathlib import Path
+# from dotenv import load_dotenv
+
+# load_dotenv()
+
+# # Set the Hugging Face API key
+# # Retrieve Hugging Face API key from environment variables
+# hf_api_key = os.getenv('HF_API_KEY')
+# if not hf_api_key:
+#     raise ValueError("HF_API_KEY not set in environment variables")
+
+# # Create the Hugging Face inference client
+# client = InferenceClient(api_key=hf_api_key)
+
+# # Constants
+# INTERVENTION_COLUMN = 'Did the intervention happen today?'
+# ENGAGED_STR = 'Engaged (Respect, Responsibility, Effort)'
+# PARTIALLY_ENGAGED_STR = 'Partially Engaged (about 50%)'
+# NOT_ENGAGED_STR = 'Not Engaged (less than 50%)'
+
+# def main():
+#     st.title("Intervention Program Analysis")
+
+#     # File uploader
+#     uploaded_file = st.file_uploader("Upload your Excel file", type=["xlsx"])
+
+#     if uploaded_file is not None:
+#         try:
+#             # Read the Excel file into a DataFrame
+#             df = pd.read_excel(uploaded_file)
+#             st.subheader("Uploaded Data")
+#             st.write(df.head(4))  # Display only the first four rows
+
+#             # Ensure expected column is available
+#             if INTERVENTION_COLUMN not in df.columns:
+#                 st.error(f"Expected column '{INTERVENTION_COLUMN}' not found.")
+#                 return
+
+#             # Clean up column names
+#             df.columns = df.columns.str.strip()
+
+#             # Compute Intervention Session Statistics
+#             intervention_stats = compute_intervention_statistics(df)
+#             st.subheader("Intervention Session Statistics")
+#             st.write(intervention_stats)
+
+#             # Visualization for Intervention Session Statistics
+#             intervention_fig = plot_intervention_statistics(intervention_stats)
+
+#             # Add download button for Intervention Session Statistics chart
+#             download_chart(intervention_fig, "intervention_statistics_chart.png")
+
+#             # Compute Student Metrics
+#             student_metrics_df = compute_student_metrics(df)
+#             st.subheader("Student Metrics")
+#             st.write(student_metrics_df)
+
+#             # Visualization for Student Metrics
+#             student_metrics_fig = plot_student_metrics(student_metrics_df)
+
+#             # Add download button for Student Metrics chart
+#             download_chart(student_metrics_fig, "student_metrics_chart.png")
+
+#             # Prepare input for the language model
+#             llm_input = prepare_llm_input(student_metrics_df)
+
+#             # Generate Notes and Recommendations using Hugging Face LLM
+#             with st.spinner("Generating AI analysis..."):
+#                 recommendations = prompt_response_from_hf_llm(llm_input)
+
+#             st.subheader("AI Analysis")
+#             st.markdown(recommendations)
+
+#             # Add download button for LLM output
+#             download_llm_output(recommendations, "llm_output.txt")
+
+#         except Exception as e:
+#             st.error(f"Error reading the file: {str(e)}")
+
+# def compute_intervention_statistics(df):
+#     # Total Number of Days Available
+#     total_days = len(df)
+
+#     # Intervention Sessions Held
+#     sessions_held = df[INTERVENTION_COLUMN].str.strip().str.lower().eq('yes').sum()
+
+#     # Intervention Sessions Not Held
+#     sessions_not_held = df[INTERVENTION_COLUMN].str.strip().str.lower().eq('no').sum()
 
-# Initialize chat history
-if 'history' not in st.session_state:
-    st.session_state['history'] = []
+#     # Intervention Frequency (%)
+#     intervention_frequency = (sessions_held / total_days) * 100 if total_days > 0 else 0
+#     intervention_frequency = round(intervention_frequency, 2)
+
+#     # Create a DataFrame to display the statistics
+#     stats = {
+#         'Total Number of Days Available': [total_days],
+#         'Intervention Sessions Held': [sessions_held],
+#         'Intervention Sessions Not Held': [sessions_not_held],
+#         'Intervention Frequency (%)': [intervention_frequency]
+#     }
+#     stats_df = pd.DataFrame(stats)
+#     return stats_df
+
+# def plot_intervention_statistics(intervention_stats):
+#     # Create a stacked bar chart for sessions held and not held
+#     sessions_held = intervention_stats['Intervention Sessions Held'].values[0]
+#     sessions_not_held = intervention_stats['Intervention Sessions Not Held'].values[0]
+
+#     fig, ax = plt.subplots()
+#     ax.bar(['Intervention Sessions'], [sessions_not_held], label='Not Held', color='#358E66')
+#     ax.bar(['Intervention Sessions'], [sessions_held], bottom=[sessions_not_held], label='Held', color='#91D6B8')
+
+#     # Display the values on the bars
+#     ax.text(0, sessions_not_held / 2, str(sessions_not_held), ha='center', va='center', color='white')
+#     ax.text(0, sessions_not_held + sessions_held / 2, str(sessions_held), ha='center', va='center', color='black')
+
+#     ax.set_ylabel('Number of Sessions')
+#     ax.set_title('Intervention Sessions Held vs Not Held')
+#     ax.legend()
+
+#     st.pyplot(fig)
+
+#     return fig
+
+# def compute_student_metrics(df):
+#     # Filter DataFrame for sessions where intervention happened
+#     intervention_df = df[df[INTERVENTION_COLUMN].str.strip().str.lower() == 'yes']
+#     intervention_sessions_held = len(intervention_df)
+
+#     # Get list of student columns
+#     student_columns = [col for col in df.columns if col.startswith('Student Attendance')]
+
+#     student_metrics = {}
+
+#     for col in student_columns:
+#         student_name = col.replace('Student Attendance [', '').replace(']', '').strip()
+#         # Get the attendance data for the student
+#         student_data = intervention_df[[col]].copy()
+
+#         # Treat blank entries as 'Absent'
+#         student_data[col] = student_data[col].fillna('Absent')
+
+#         # Assign attendance values
+#         attendance_values = student_data[col].apply(lambda x: 1 if x in [
+#             ENGAGED_STR,
+#             PARTIALLY_ENGAGED_STR,
+#             NOT_ENGAGED_STR
+#         ] else 0)
+
+#         # Number of Sessions Attended
+#         sessions_attended = attendance_values.sum()
+
+#         # Attendance (%)
+#         attendance_pct = (sessions_attended / intervention_sessions_held) * 100 if intervention_sessions_held > 0 else 0
+#         attendance_pct = round(attendance_pct, 2)
+
+#         # For engagement calculation, include only sessions where attendance is not 'Absent'
+#         valid_engagement_indices = attendance_values[attendance_values == 1].index
+#         engagement_data = student_data.loc[valid_engagement_indices, col]
+
+#         # Assign engagement values
+#         engagement_values = engagement_data.apply(lambda x: 1 if x == ENGAGED_STR
+#                                                   else 0.5 if x == PARTIALLY_ENGAGED_STR else 0)
+
+#         # Sum of Engagement Values
+#         sum_engagement_values = engagement_values.sum()
+
+#         # Number of Sessions Attended for engagement (should be same as sessions_attended)
+#         number_sessions_attended = len(valid_engagement_indices)
+
+#         # Engagement (%)
+#         engagement_pct = (sum_engagement_values / number_sessions_attended) * 100 if number_sessions_attended > 0 else 0
+#         engagement_pct = round(engagement_pct, 2)
+
+#         # Store metrics
+#         student_metrics[student_name] = {
+#             'Attendance (%)': attendance_pct,
+#             'Engagement (%)': engagement_pct
+#         }
+
+#     # Create a DataFrame from student_metrics
+#     student_metrics_df = pd.DataFrame.from_dict(student_metrics, orient='index').reset_index()
+#     student_metrics_df.rename(columns={'index': 'Student'}, inplace=True)
+#     return student_metrics_df
+
+# def plot_student_metrics(student_metrics_df):
+#     # Create a line graph for attendance and engagement
+#     fig, ax = plt.subplots()
+
+#     # Plotting Attendance and Engagement with specific colors
+#     ax.plot(student_metrics_df['Student'], student_metrics_df['Attendance (%)'], marker='o', color='#005288', label='Attendance (%)')
+#     ax.plot(student_metrics_df['Student'], student_metrics_df['Engagement (%)'], marker='o', color='#3AB0FF', label='Engagement (%)')
+
+#     ax.set_xlabel('Student')
+#     ax.set_ylabel('Percentage (%)')
+#     ax.set_title('Student Attendance and Engagement Metrics')
+#     ax.legend()
+#     plt.xticks(rotation=45)
+
+#     st.pyplot(fig)
+
+#     return fig
+
+# def download_chart(fig, filename):
+#     # Create a buffer to hold the image data
+#     buffer = io.BytesIO()
+#     # Save the figure to the buffer
+#     fig.savefig(buffer, format='png')
+#     # Set the file pointer to the beginning
+#     buffer.seek(0)
+#     # Add a download button to Streamlit
+#     st.download_button(label="Download Chart", data=buffer, file_name=filename, mime='image/png')
+
+# def download_llm_output(content, filename):
+#     # Create a buffer to hold the text data
+#     buffer = io.BytesIO()
+#     buffer.write(content.encode('utf-8'))
+#     buffer.seek(0)
+#     # Add a download button to Streamlit
+#     st.download_button(label="Download LLM Output", data=buffer, file_name=filename, mime='text/plain')
+
+# def prepare_llm_input(student_metrics_df):
+#     # Convert the student metrics DataFrame to a string
+#     metrics_str = student_metrics_df.to_string(index=False)
+#     llm_input = f"""
+# Based on the following student metrics:
+
+# {metrics_str}
+
+# Provide:
+
+# 1. Notes and Key Takeaways: Summarize the data, highlight students with the lowest and highest attendance and engagement percentages, identify students who may need adjustments to their intervention due to low attendance or engagement, and highlight students who are showing strong performance. 
+
+# 2. Recommendations and Next Steps: Provide interpretations based on the analysis and suggest possible next steps or strategies to improve student outcomes.
+# """
+#     return llm_input
+
+# def prompt_response_from_hf_llm(llm_input):
+#     # Generate the refined prompt using Hugging Face API
+#     response = client.chat.completions.create(
+#         model="meta-llama/Llama-3.1-70B-Instruct",
+#         messages=[
+#             {"role": "user", "content": llm_input}
+#         ],
+#         stream=True,
+#         temperature=0.5,
+#         max_tokens=1024,
+#         top_p=0.7
+#     )
     
-# # STREAMLIT APPLICATION SETUP WITH PASSWORD
+#     # Combine messages if response is streamed
+#     response_content = ""
+#     for message in response:
+#         response_content += message.choices[0].delta.content
+
+#     return response_content.strip()
 
-# Define the correct password
-# correct_password = "MiBLSi"
+# if __name__ == '__main__':
+#     main()
+
+
+# CHARTS + DOWNLOAD + NO NAMES
+# intervention_analysis_app.py
+
+#------------------------------------------------------------------------
+# Import Modules
+#------------------------------------------------------------------------
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+import io
+import re
+# from transformers import pipeline
+from huggingface_hub import InferenceClient
+import os
+from pathlib import Path
+from dotenv import load_dotenv
 
-#Add the image with a specified width
-image_width = 300  # Set the desired width in pixels
-st.image('MTSS.ai_Logo.png', width=image_width)
-st.subheader('Ink QA™ | Dynamic PDFs')
+load_dotenv()
 
-# Using Markdown for formatted text
-st.markdown("""
-Resource: **Intensifying Literacy Instruction: Essential Practices**
-""", unsafe_allow_html=True)
+#------------------------------------------------------------------------
+# Configurations
+#------------------------------------------------------------------------
+# Streamlit page setup
+st.set_page_config(
+    page_title="Intervention Program Analysis", 
+    page_icon=":bar_chart:", 
+    layout="centered", 
+    initial_sidebar_state="auto",
+    menu_items={
+        'Get Help': 'mailto:[email protected]',
+        'About': "This app is built to support spreadsheet analysis"
+    }
+)
 
+#------------------------------------------------------------------------
+# Sidebar
+#------------------------------------------------------------------------
 with st.sidebar:
     # Password input field
     # password = st.text_input("Enter Password:", type="password")
     
-    st.image('mimtss.png', width=200)
-    st.image('Literacy_Cover.png', width=200)
-    st.link_button("View | Download", "https://mimtsstac.org/sites/default/files/session-documents/Intensifying%20Literacy%20Instruction%20-%20Essential%20Practices%20%28NATIONAL%29.pdf")
-        
-    Audio_Header_text = """
-    **Tune into Dr. St. Martin's introduction**"""
-    st.markdown(Audio_Header_text)
-        
-    # Path or URL to the audio file
-    audio_file_path = 'Audio_Introduction_Literacy.m4a'
-    # Display the audio player widget
-    st.audio(audio_file_path, format='audio/mp4', start_time=0)
-        
-    # Citation text with Markdown formatting
-    citation_Content_text = """
-    **Citation**  
-    St. Martin, K., Vaughn, S., Troia, G., Fien, & H., Coyne, M. (2023). *Intensifying literacy instruction: Essential practices, Version 2.0*. Lansing, MI: MiMTSS Technical Assistance Center, Michigan Department of Education.
-        
-    **Table of Contents**  
-    * **Introduction**: pg. 1  
-    * **Intensifying Literacy Instruction: Essential Practices**: pg. 4  
-    * **Purpose**: pg. 4  
-    * **Practice 1**: Knowledge and Use of a Learning Progression for Developing Skilled Readers and Writers: pg. 6
-    * **Practice 2**: Design and Use of an Intervention Platform as the Foundation for Effective Intervention: pg. 13
-    * **Practice 3**: On-going Data-Based Decision Making for Providing and Intensifying Interventions: pg. 16
-    * **Practice 4**: Adaptations to Increase the Instructional Intensity of the Intervention: pg. 20
-    * **Practice 5**: Infrastructures to Support Students with Significant and Persistent Literacy Needs: pg. 24
-    * **Motivation and Engagement**: pg. 28
-    * **Considerations for Understanding How Students' Learning and Behavior are Enhanced**: pg. 28
-    * **Summary**: pg. 29
-    * **Endnotes**: pg. 30
-    * **Acknowledgment**: pg. 39
-    """
-    st.markdown(citation_Content_text)
-
-# if password == correct_password:
-# Define a list of possible placeholder texts
-placeholders = [
-    'Example: Summarize the article in 200 words or less',
-    'Example: What are the essential practices?',
-    'Example: I am a teacher, why is this resource important?',
-    'Example: How can this resource support my instruction in reading and writing?',
-    'Example: Does this resource align with the learning progression for developing skilled readers and writers?',
-    'Example: How does this resource address the needs of students scoring below the 20th percentile?',
-    'Example: Are there assessment tools included in this resource to monitor student progress?',
-    'Example: Does this resource provide guidance on data collection and analysis for monitoring student outcomes?',
-    "Example: How can this resource be used to support students' social-emotional development?",
-    "Example: How does this resource align with the district's literacy goals and objectives?",
-    'Example: What research and evidence support the effectiveness of this resource?',
-    'Example: Does this resource provide guidance on implementation fidelity'
-]
-
-# Select a random placeholder from the list
-if 'placeholder' not in st.session_state:
-    st.session_state.placeholder = random.choice(placeholders)
-
-
-# CLEAR THE TEXT BOX
-with st.form("Question",clear_on_submit=True):
-    q = st.text_input(label='Ask a Question | Send a Prompt', placeholder=st.session_state.placeholder, value='', )
-    submitted = st.form_submit_button("Submit")
+    # Set the desired width in pixels
+    image_width = 300  
+    # Define the path to the image
+    image_path = "/Users/cheynelevesseur/Desktop/Manual Library/Python_Code/LLM_Projects_1/intervention_analysis_app/mimtss_logo.png"
+    # Display the image
+    st.image(image_path, width=image_width)
     
+    # Toggle for Help and Report a Bug
+    with st.expander("Need help and report a bug"):
+        st.write("""
+        **Contact**: Cheyne LeVesseur, PhD  
+        **Email**: [email protected]
+        """)
     st.divider()
+    st.subheader('User Instructions')
+    
+    # Principles text with Markdown formatting
+    User_Instructions = """
+
+    - **Step 1**: Upload your Excel file.
+    - **Step 2**: Anonymization – student names are replaced with initials for privacy.
+    - **Step 3**: Review anonymized data.
+    - **Step 4**: View **intervention session statistics**.
+    - **Step 5**: Review **student attendance and engagement metrics**.
+    - **Step 6**: Review AI-generated **insights and recommendations**.
+
+    ### **Privacy Assurance**
+    - **No full names** are ever displayed or sent to the AI model—only initials are used.
+    - This ensures that sensitive data remains protected throughout the entire process.
+
+    ### **Detailed Instructions**
+
+    #### **1. Upload Your Excel File**
+    - Start by uploading an Excel file that contains intervention data. 
+    - Click on the **“Upload your Excel file”** button and select your `.xlsx` file from your computer.
+
+    **Note**: Your file should have columns like "Did the intervention happen today?" and "Student Attendance [FirstName LastName]" for the analysis to work correctly.
+
+    #### **2. Automated Name Anonymization**
+    - Once the file is uploaded, the app will **automatically replace student names with initials** in the "Student Attendance" columns.
+      - For example, **"Student Attendance [Cheyne LeVesseur]"** will be displayed as **"Student Attendance [CL]"**.
+      - If the student only has a first name, like **"Student Attendance [Cheyne]"**, it will be displayed as **"Student Attendance [C]"**.
+    - This anonymization helps to **protect student privacy**, ensuring that full names are not visible or sent to the AI language model.
+
+    #### **3. Review the Uploaded Data**
+    - You will see the entire table of anonymized data to verify that the information has been uploaded correctly and that names have been replaced with initials.
+
+    #### **4. Intervention Session Statistics**
+    - The app will calculate and display statistics related to intervention sessions, such as:
+      - **Total Number of Days Available**
+      - **Intervention Sessions Held**
+      - **Intervention Sessions Not Held**
+      - **Intervention Frequency (%)**
+    - A **stacked bar chart** will be shown to visualize the number of sessions held versus not held.
+    - If you need to save the visualization, click the **“Download Chart”** button to download it as a `.png` file.
+
+    #### **5. Student Metrics Analysis**
+    - The app will also calculate metrics for each student:
+      - **Attendance (%)** – The percentage of intervention sessions attended.
+      - **Engagement (%)** – The level of engagement during attended sessions.
+    - These metrics will be presented in a **line graph** that shows attendance and engagement for each student.
+    - You can click the **“Download Chart”** button to download the visualization as a `.png` file.
+
+    #### **6. Generate AI Analysis and Recommendations**
+    - The app will prepare data from the student metrics to provide notes, key takeaways, and suggestions for improving outcomes using an **AI language model**.
+    - You will see a **spinner** labeled **“Generating AI analysis…”** while the AI processes the data.
+      - This step may take a little longer, but the spinner ensures you know that the system is working.
+    - Once the analysis is complete, the AI's recommendations will be displayed under **"AI Analysis"**.
+    - You can click the **“Download LLM Output”** button to download the AI-generated recommendations as a `.txt` file for future reference.
+
+    """
+    st.markdown(User_Instructions)
+
+#------------------------------------------------------------------------
+# Functions
+#------------------------------------------------------------------------
+# Set the Hugging Face API key
+# Retrieve Hugging Face API key from environment variables
+hf_api_key = os.getenv('HF_API_KEY')
+if not hf_api_key:
+    raise ValueError("HF_API_KEY not set in environment variables")
+
+# Create the Hugging Face inference client
+client = InferenceClient(api_key=hf_api_key)
+
+# Constants
+INTERVENTION_COLUMN = 'Did the intervention happen today?'
+ENGAGED_STR = 'Engaged (Respect, Responsibility, Effort)'
+PARTIALLY_ENGAGED_STR = 'Partially Engaged (about 50%)'
+NOT_ENGAGED_STR = 'Not Engaged (less than 50%)'
+
+def main():
+    st.title("Intervention Program Analysis")
+
+    # File uploader
+    uploaded_file = st.file_uploader("Upload your Excel file", type=["xlsx"])
+
+    if uploaded_file is not None:
+        try:
+            # Read the Excel file into a DataFrame
+            df = pd.read_excel(uploaded_file)
+
+            # Replace student names with initials
+            df = replace_student_names_with_initials(df)
+
+            st.subheader("Uploaded Data")
+            st.write(df.head(4))  # Display only the first four rows
+
+            # Ensure expected column is available
+            if INTERVENTION_COLUMN not in df.columns:
+                st.error(f"Expected column '{INTERVENTION_COLUMN}' not found.")
+                return
+
+            # Clean up column names
+            df.columns = df.columns.str.strip()
+
+            # Compute Intervention Session Statistics
+            intervention_stats = compute_intervention_statistics(df)
+            st.subheader("Intervention Session Statistics")
+            st.write(intervention_stats)
+
+            # Visualization for Intervention Session Statistics
+            intervention_fig = plot_intervention_statistics(intervention_stats)
+
+            # Add download button for Intervention Session Statistics chart
+            download_chart(intervention_fig, "intervention_statistics_chart.png")
+
+            # Compute Student Metrics
+            student_metrics_df = compute_student_metrics(df)
+            st.subheader("Student Metrics")
+            st.write(student_metrics_df)
+
+            # Visualization for Student Metrics
+            student_metrics_fig = plot_student_metrics(student_metrics_df)
+
+            # Add download button for Student Metrics chart
+            download_chart(student_metrics_fig, "student_metrics_chart.png")
+
+            # Prepare input for the language model
+            llm_input = prepare_llm_input(student_metrics_df)
+
+            # Generate Notes and Recommendations using Hugging Face LLM
+            with st.spinner("Generating AI analysis..."):
+                recommendations = prompt_response_from_hf_llm(llm_input)
+
+            st.subheader("AI Analysis")
+            st.markdown(recommendations)
+
+            # Add download button for LLM output
+            download_llm_output(recommendations, "llm_output.txt")
+
+        except Exception as e:
+            st.error(f"Error reading the file: {str(e)}")
+
+def replace_student_names_with_initials(df):
+    """Replace student names in column headers with initials."""
+    updated_columns = []
+    for col in df.columns:
+        if col.startswith('Student Attendance'):
+            # Extract the name from the column header
+            match = re.match(r'Student Attendance \[(.+?)\]', col)
+            if match:
+                name = match.group(1)
+                # Split the name into parts (first and last name)
+                name_parts = name.split()
+                # Convert the name to initials
+                if len(name_parts) == 1:
+                    initials = name_parts[0][0]  # Just take the first letter
+                else:
+                    initials = ''.join([part[0] for part in name_parts])  # Take the first letter of each part
+                # Update the column name
+                updated_columns.append(f'Student Attendance [{initials}]')
+            else:
+                updated_columns.append(col)
+        else:
+            updated_columns.append(col)
+    df.columns = updated_columns
+    return df
+
+def compute_intervention_statistics(df):
+    # Total Number of Days Available
+    total_days = len(df)
+
+    # Intervention Sessions Held
+    sessions_held = df[INTERVENTION_COLUMN].str.strip().str.lower().eq('yes').sum()
+
+    # Intervention Sessions Not Held
+    sessions_not_held = df[INTERVENTION_COLUMN].str.strip().str.lower().eq('no').sum()
+
+    # Intervention Frequency (%)
+    intervention_frequency = (sessions_held / total_days) * 100 if total_days > 0 else 0
+    intervention_frequency = round(intervention_frequency, 2)
+
+    # Create a DataFrame to display the statistics
+    stats = {
+        'Total Number of Days Available': [total_days],
+        'Intervention Sessions Held': [sessions_held],
+        'Intervention Sessions Not Held': [sessions_not_held],
+        'Intervention Frequency (%)': [intervention_frequency]
+    }
+    stats_df = pd.DataFrame(stats)
+    return stats_df
+
+def plot_intervention_statistics(intervention_stats):
+    # Create a stacked bar chart for sessions held and not held
+    sessions_held = intervention_stats['Intervention Sessions Held'].values[0]
+    sessions_not_held = intervention_stats['Intervention Sessions Not Held'].values[0]
+
+    fig, ax = plt.subplots()
+    ax.bar(['Intervention Sessions'], [sessions_not_held], label='Not Held', color='#358E66')
+    ax.bar(['Intervention Sessions'], [sessions_held], bottom=[sessions_not_held], label='Held', color='#91D6B8')
+
+    # Display the values on the bars
+    ax.text(0, sessions_not_held / 2, str(sessions_not_held), ha='center', va='center', color='white')
+    ax.text(0, sessions_not_held + sessions_held / 2, str(sessions_held), ha='center', va='center', color='black')
+
+    ax.set_ylabel('Number of Sessions')
+    ax.set_title('Intervention Sessions Held vs Not Held')
+    ax.legend()
+
+    st.pyplot(fig)
+
+    return fig
+
+def compute_student_metrics(df):
+    # Filter DataFrame for sessions where intervention happened
+    intervention_df = df[df[INTERVENTION_COLUMN].str.strip().str.lower() == 'yes']
+    intervention_sessions_held = len(intervention_df)
+
+    # Get list of student columns
+    student_columns = [col for col in df.columns if col.startswith('Student Attendance')]
+
+    student_metrics = {}
+
+    for col in student_columns:
+        student_name = col.replace('Student Attendance [', '').replace(']', '').strip()
+        # Get the attendance data for the student
+        student_data = intervention_df[[col]].copy()
+
+        # Treat blank entries as 'Absent'
+        student_data[col] = student_data[col].fillna('Absent')
+
+        # Assign attendance values
+        attendance_values = student_data[col].apply(lambda x: 1 if x in [
+            ENGAGED_STR,
+            PARTIALLY_ENGAGED_STR,
+            NOT_ENGAGED_STR
+        ] else 0)
+
+        # Number of Sessions Attended
+        sessions_attended = attendance_values.sum()
+
+        # Attendance (%)
+        attendance_pct = (sessions_attended / intervention_sessions_held) * 100 if intervention_sessions_held > 0 else 0
+        attendance_pct = round(attendance_pct, 2)
+
+        # For engagement calculation, include only sessions where attendance is not 'Absent'
+        valid_engagement_indices = attendance_values[attendance_values == 1].index
+        engagement_data = student_data.loc[valid_engagement_indices, col]
+
+        # Assign engagement values
+        engagement_values = engagement_data.apply(lambda x: 1 if x == ENGAGED_STR
+                                                  else 0.5 if x == PARTIALLY_ENGAGED_STR else 0)
+
+        # Sum of Engagement Values
+        sum_engagement_values = engagement_values.sum()
+
+        # Number of Sessions Attended for engagement (should be same as sessions_attended)
+        number_sessions_attended = len(valid_engagement_indices)
+
+        # Engagement (%)
+        engagement_pct = (sum_engagement_values / number_sessions_attended) * 100 if number_sessions_attended > 0 else 0
+        engagement_pct = round(engagement_pct, 2)
+
+        # Store metrics
+        student_metrics[student_name] = {
+            'Attendance (%)': attendance_pct,
+            'Engagement (%)': engagement_pct
+        }
+
+    # Create a DataFrame from student_metrics
+    student_metrics_df = pd.DataFrame.from_dict(student_metrics, orient='index').reset_index()
+    student_metrics_df.rename(columns={'index': 'Student'}, inplace=True)
+    return student_metrics_df
+
+def plot_student_metrics(student_metrics_df):
+    # Create a line graph for attendance and engagement
+    fig, ax = plt.subplots()
+
+    # Plotting Attendance and Engagement with specific colors
+    ax.plot(student_metrics_df['Student'], student_metrics_df['Attendance (%)'], marker='o', color='#005288', label='Attendance (%)')
+    ax.plot(student_metrics_df['Student'], student_metrics_df['Engagement (%)'], marker='o', color='#3AB0FF', label='Engagement (%)')
+
+    ax.set_xlabel('Student')
+    ax.set_ylabel('Percentage (%)')
+    ax.set_title('Student Attendance and Engagement Metrics')
+    ax.legend()
+    plt.xticks(rotation=45)
+
+    st.pyplot(fig)
+
+    return fig
+
+def download_chart(fig, filename):
+    # Create a buffer to hold the image data
+    buffer = io.BytesIO()
+    # Save the figure to the buffer
+    fig.savefig(buffer, format='png')
+    # Set the file pointer to the beginning
+    buffer.seek(0)
+    # Add a download button to Streamlit
+    st.download_button(label="Download Chart", data=buffer, file_name=filename, mime='image/png')
+
+def download_llm_output(content, filename):
+    # Create a buffer to hold the text data
+    buffer = io.BytesIO()
+    buffer.write(content.encode('utf-8'))
+    buffer.seek(0)
+    # Add a download button to Streamlit
+    st.download_button(label="Download LLM Output", data=buffer, file_name=filename, mime='text/plain')
+
+def prepare_llm_input(student_metrics_df):
+    # Convert the student metrics DataFrame to a string
+    metrics_str = student_metrics_df.to_string(index=False)
+    llm_input = f"""
+Based on the following student metrics:
+
+{metrics_str}
+
+Provide:
+
+1. Notes and Key Takeaways: Summarize the data, highlight students with the lowest and highest attendance and engagement percentages, identify students who may need adjustments to their intervention due to low attendance or engagement, and highlight students who are showing strong performance. 
+
+2. Recommendations and Next Steps: Provide interpretations based on the analysis and suggest possible next steps or strategies to improve student outcomes.
+"""
+    return llm_input
+
+def prompt_response_from_hf_llm(llm_input):
+    # Generate the refined prompt using Hugging Face API
+    response = client.chat.completions.create(
+        model="meta-llama/Llama-3.1-70B-Instruct",
+        messages=[
+            {"role": "user", "content": llm_input}
+        ],
+        stream=True,
+        temperature=0.5,
+        max_tokens=1024,
+        top_p=0.7
+    )
     
-    if submitted:
-        with st.spinner('Thinking...'):
-            answer = ask_with_memory(vector_store, q, st.session_state.history)
-        
-        # st.write(q)
-        st.write(f"**{q}**")
-        
-        import time
-        import random
-
-        def stream_answer():
-            for word in answer.split(" "):
-                yield word + " "
-                # time.sleep(0.02)
-                time.sleep(random.uniform(0.03, 0.08))
-        
-        st.write(stream_answer)
-        
-        # Display the response in a text area
-        # st.text_area('Response: ', value=answer, height=400, key="response_text_area")
-        # OR to display as Markdown (interprets Markdown formatting)
-        # st.markdown(answer)
-            
-        st.success('Powered by MTSS GPT. AI can make mistakes. Consider checking important information.')
-        
-        st.divider()
-
-        # # Prepare chat history text for display
-        history_text = "\n\n".join(f"Q: {entry[0]}\nA: {entry[1]}" for entry in reversed(st.session_state.history))
-
-        # Display chat history
-        st.text_area('Chat History', value=history_text, height=800)
+    # Combine messages if response is streamed
+    response_content = ""
+    for message in response:
+        response_content += message.choices[0].delta.content
+
+    return response_content.strip()
+
+if __name__ == '__main__':
+    main()