Upload 18 files

pages/ai_buddy.py

@@ -0,0 +1,368 @@
+import streamlit as st
+import random
+from langchain.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+import os
+from dotenv import load_dotenv
+import pandas as pd
+from datetime import datetime
+import plotly.express as px
+import json
+import speech_recognition as sr
+from gtts import gTTS
+import pygame
+from io import BytesIO
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = "api71-api-92fc2ef9-9f3c-47e5-a019-18e257b04af2"
+
+# Initialize the Falcon model
+chat = ChatOpenAI(
+    model="tiiuae/falcon-180B-chat",
+    api_key=AI71_API_KEY,
+    base_url=AI71_BASE_URL,
+    streaming=True,
+)
+
+# Expanded Therapy techniques
+THERAPY_TECHNIQUES = {
+    "CBT": "Use Cognitive Behavioral Therapy techniques to help the user identify and change negative thought patterns.",
+    "Mindfulness": "Guide the user through mindfulness exercises to promote present-moment awareness and reduce stress.",
+    "Solution-Focused": "Focus on the user's strengths and resources to help them find solutions to their problems.",
+    "Emotion-Focused": "Help the user identify, experience, and regulate their emotions more effectively.",
+    "Psychodynamic": "Explore the user's past experiences and unconscious patterns to gain insight into current issues.",
+    "ACT": "Use Acceptance and Commitment Therapy to help the user accept their thoughts and feelings while committing to positive changes.",
+    "DBT": "Apply Dialectical Behavior Therapy techniques to help the user manage intense emotions and improve relationships.",
+    "Gestalt": "Use Gestalt therapy techniques to focus on the present moment and increase self-awareness.",
+    "Existential": "Explore existential themes such as meaning, freedom, and responsibility to help the user find purpose.",
+    "Narrative": "Use storytelling and narrative techniques to help the user reframe their life experiences and create new meaning.",
+}
+
+def get_ai_response(user_input, buddy_config, therapy_technique=None):
+    system_message = f"You are {buddy_config['name']}, an AI companion with the following personality: {buddy_config['personality']}. "
+    system_message += f"Additional details about you: {buddy_config['details']}. "
+    
+    if therapy_technique:
+        system_message += f"In this conversation, {THERAPY_TECHNIQUES[therapy_technique]}"
+    
+    messages = [
+        SystemMessage(content=system_message),
+        HumanMessage(content=user_input)
+    ]
+    response = chat.invoke(messages).content
+    return response
+
+def show_progress_dashboard():
+    st.subheader("Your Progress Dashboard")
+    
+    # Placeholder data for demonstration
+    mood_logs = [{"date": "2023-08-01", "mood": 7}, {"date": "2023-08-02", "mood": 8}, {"date": "2023-08-03", "mood": 6}]
+    
+    # Mood trend
+    if mood_logs:
+        df = pd.DataFrame(mood_logs)
+        fig = px.line(df, x="date", y="mood", title="Mood Trend")
+        st.plotly_chart(fig)
+    else:
+        st.info("No mood data available yet. Start logging your mood!")
+    
+    # Journal entries
+    st.subheader("Recent Journal Entries")
+    journal_entries = [
+        {"date": "2023-08-03", "entry": "Had a productive day at work..."},
+        {"date": "2023-08-02", "entry": "Feeling a bit stressed about..."},
+        {"date": "2023-08-01", "entry": "Started a new book today..."}
+    ]
+    for entry in journal_entries[-5:]:
+        st.text(f"{entry['date']}: {entry['entry'][:50]}...")
+    
+    # Goals progress
+    st.subheader("Goals Progress")
+    goals = [
+        {"description": "Exercise 3 times a week", "progress": 60},
+        {"description": "Read 2 books this month", "progress": 75},
+        {"description": "Learn Python programming", "progress": 40}
+    ]
+    for goal in goals:
+        st.progress(goal['progress'])
+        st.text(f"{goal['description']}: {goal['progress']}% complete")
+
+def show_goal_setting_interface():
+    st.subheader("Set Your Goals")
+    goal_description = st.text_input("Describe your goal")
+    goal_progress = st.slider("Initial progress", 0, 100, 0)
+    
+    if st.button("Add Goal"):
+        st.success("Goal added successfully!")
+
+def show_meditation_timer():
+    st.subheader("Meditation Timer")
+    duration = st.slider("Select duration (minutes)", 1, 60, 5)
+    if st.button("Start Meditation"):
+        progress_bar = st.progress(0)
+        for i in range(duration * 60):
+            progress_bar.progress((i + 1) / (duration * 60))
+            st.empty().text(f"Time remaining: {duration - (i // 60)}:{59 - (i % 60):02d}")
+            time.sleep(1)
+        st.success("Meditation complete!")
+
+def show_community_forum():
+    st.subheader("Community Forum")
+    st.warning("This feature is not yet implemented. Check back soon!")
+
+def show_personalized_recommendations():
+    st.subheader("Personalized Recommendations")
+    
+    # Placeholder for demonstration
+    avg_mood = 6
+    
+    if avg_mood < 4:
+        st.markdown("Based on your recent mood, we recommend:")
+        st.markdown("- Practice daily gratitude journaling")
+        st.markdown("- Try a guided meditation for stress relief")
+        st.markdown("- Read 'The Happiness Trap' by Russ Harris")
+    elif avg_mood < 7:
+        st.markdown("To maintain and improve your mood, consider:")
+        st.markdown("- Start a new hobby or learn a new skill")
+        st.markdown("- Practice mindfulness meditation")
+        st.markdown("- Read 'Atomic Habits' by James Clear")
+    else:
+        st.markdown("Great job maintaining a positive mood! To keep it up:")
+        st.markdown("- Share your positivity with others")
+        st.markdown("- Set ambitious goals for personal growth")
+        st.markdown("- Read 'Flow' by Mihaly Csikszentmihalyi")
+
+def start_voice_interaction():
+    st.subheader("Voice Interaction")
+    if st.button("Start Voice Recognition"):
+        r = sr.Recognizer()
+        with sr.Microphone() as source:
+            st.info("Listening... Speak now!")
+            audio = r.listen(source)
+            try:
+                text = r.recognize_google(audio)
+                st.success(f"You said: {text}")
+                
+                # Get AI response
+                buddy_config = {
+                    "name": st.session_state.buddy_name,
+                    "personality": st.session_state.buddy_personality,
+                    "details": st.session_state.buddy_details
+                }
+                response = get_ai_response(text, buddy_config)
+                
+                # Convert response to speech
+                tts = gTTS(text=response, lang='en')
+                fp = BytesIO()
+                tts.write_to_fp(fp)
+                fp.seek(0)
+                
+                # Play the response
+                pygame.mixer.init()
+                pygame.mixer.music.load(fp)
+                pygame.mixer.music.play()
+                while pygame.mixer.music.get_busy():
+                    pygame.time.Clock().tick(10)
+                
+                st.success(f"AI response: {response}")
+            except sr.UnknownValueError:
+                st.error("Sorry, I couldn't understand what you said.")
+            except sr.RequestError as e:
+                st.error(f"Could not request results; {e}")
+
+def show_daily_challenge():
+    st.subheader("Daily Personal Growth Challenge")
+    challenges = [
+        "Write down three things you're grateful for today.",
+        "Reach out to a friend or family member you haven't spoken to in a while.",
+        "Try a new healthy recipe for dinner tonight.",
+        "Take a 15-minute walk in nature and practice mindfulness.",
+        "Learn five new words in a language you're interested in.",
+        "Declutter one area of your living space.",
+        "Practice active listening in your next conversation.",
+        "Try a new form of exercise or physical activity.",
+        "Write a short story or poem expressing your current emotions.",
+        "Perform a random act of kindness for someone."
+    ]
+    
+    if 'daily_challenge' not in st.session_state:
+        st.session_state.daily_challenge = random.choice(challenges)
+    
+    st.info(f"Your challenge for today: {st.session_state.daily_challenge}")
+    
+    if st.button("Complete Challenge"):
+        st.success("Great job completing today's challenge! Keep up the good work.")
+        st.session_state.daily_challenge = random.choice(challenges)
+
+def show_therapist_scheduling_interface():
+    st.subheader("Schedule a Video Therapy Session")
+    st.warning("This feature would integrate with a real therapist booking system. For demonstration purposes, we'll use a simplified version.")
+    
+    therapists = ["Dr. Smith", "Dr. Johnson", "Dr. Williams", "Dr. Brown"]
+    selected_therapist = st.selectbox("Choose a therapist", therapists)
+    
+    date = st.date_input("Select a date")
+    time = st.time_input("Select a time")
+    
+    if st.button("Schedule Session"):
+        st.success(f"Session scheduled with {selected_therapist} on {date} at {time}. You will receive a confirmation email with further details.")
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. AI Buddy", page_icon="🕵️", layout="wide")
+    
+    # Custom CSS for improved styling
+    st.markdown("""
+    <style>
+    .stApp {
+        background-color: #f0f2f6;
+    }
+    .stButton>button {
+        background-color: #4CAF50;
+        color: white;
+        font-weight: bold;
+    }
+    .stTextInput>div>div>input {
+        background-color: #ffffff;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    st.title("🕵️ S.H.E.R.L.O.C.K. AI Buddy")
+    st.markdown("Your personalized AI companion for conversation, therapy, and personal growth.")
+
+    # Initialize session state
+    if 'buddy_name' not in st.session_state:
+        st.session_state.buddy_name = "Sherlock"
+    if 'buddy_personality' not in st.session_state:
+        st.session_state.buddy_personality = "Friendly, empathetic, and insightful"
+    if 'buddy_details' not in st.session_state:
+        st.session_state.buddy_details = "Knowledgeable about various therapy techniques and always ready to listen"
+    if 'messages' not in st.session_state:
+        st.session_state.messages = []
+
+    # Sidebar for AI Buddy configuration
+    with st.sidebar:
+        st.header("🤖 Configure Your AI Buddy")
+        st.session_state.buddy_name = st.text_input("Name your AI Buddy", value=st.session_state.buddy_name)
+        st.session_state.buddy_personality = st.text_area("Describe your buddy's personality", value=st.session_state.buddy_personality)
+        st.session_state.buddy_details = st.text_area("Additional details about your buddy", value=st.session_state.buddy_details)
+        
+        st.header("🧘 Therapy Session")
+        therapy_mode = st.checkbox("Enable Therapy Mode")
+        if therapy_mode:
+            therapy_technique = st.selectbox("Select Therapy Technique", list(THERAPY_TECHNIQUES.keys()))
+        else:
+            therapy_technique = None
+        
+        st.markdown("---")
+        st.markdown("Powered by Falcon-180B and Streamlit")
+
+    # Main content area
+    tab1, tab2, tab3, tab4, tab5 = st.tabs(["Chat", "Progress", "Goals", "Community", "Tools"])
+    
+    with tab1:
+        # Chat interface
+        st.header("🗨️ Chat with Your AI Buddy")
+        chat_container = st.container()
+        with chat_container:
+            for message in st.session_state.messages[-5:]:  # Display last 5 messages
+                with st.chat_message(message["role"]):
+                    st.markdown(message["content"])
+
+        # User input
+        if prompt := st.chat_input("What's on your mind?"):
+            st.session_state.messages.append({"role": "user", "content": prompt})
+            with st.chat_message("user"):
+                st.markdown(prompt)
+
+            buddy_config = {
+                "name": st.session_state.buddy_name,
+                "personality": st.session_state.buddy_personality,
+                "details": st.session_state.buddy_details
+            }
+
+            with st.chat_message("assistant"):
+                message_placeholder = st.empty()
+                full_response = ""
+                for chunk in chat.stream(get_ai_response(prompt, buddy_config, therapy_technique)):
+                    full_response += chunk.content
+                    message_placeholder.markdown(full_response + "▌")
+                message_placeholder.markdown(full_response)
+            st.session_state.messages.append({"role": "assistant", "content": full_response})
+
+    with tab2:
+        show_progress_dashboard()
+
+    with tab3:
+        show_goal_setting_interface()
+
+    with tab4:
+        show_community_forum()
+
+    with tab5:
+        tool_choice = st.selectbox("Select a tool", ["Meditation Timer", "Recommendations", "Voice Interaction", "Daily Challenge", "Schedule Therapy"])
+        if tool_choice == "Meditation Timer":
+            show_meditation_timer()
+        elif tool_choice == "Recommendations":
+            show_personalized_recommendations()
+        elif tool_choice == "Voice Interaction":
+            start_voice_interaction()
+        elif tool_choice == "Daily Challenge":
+            show_daily_challenge()
+        elif tool_choice == "Schedule Therapy":
+            show_therapist_scheduling_interface()
+
+    # Mood tracker
+    st.sidebar.markdown("---")
+    st.sidebar.header("😊 Mood Tracker")
+    mood = st.sidebar.slider("How are you feeling today?", 1, 10, 5)
+    if st.sidebar.button("Log Mood"):
+        st.sidebar.success(f"Mood logged: {mood}/10")
+        st.balloons()
+
+    # Journaling feature
+    st.sidebar.markdown("---")
+    st.sidebar.header("📔 Daily Journal")
+    journal_entry = st.sidebar.text_area("Write your thoughts for today")
+    if st.sidebar.button("Save Journal Entry"):
+        st.sidebar.success("Journal entry saved!")
+        st.toast("Journal entry saved successfully!", icon="✅")
+
+    # Resources and Emergency Contact
+    st.sidebar.markdown("---")
+    st.sidebar.header("🆘 Resources")
+    st.sidebar.info("If you're in crisis, please reach out for help:")
+    st.sidebar.markdown("- [Mental Health Resources](https://www.mentalhealth.gov/get-help/immediate-help)")
+    st.sidebar.markdown("- Emergency Contact: 911 or your local emergency number")
+
+    # Inspiration Quote
+    st.sidebar.markdown("---")
+    st.sidebar.header("💡 Daily Inspiration")
+    if st.sidebar.button("Get Inspirational Quote"):
+        quotes = [
+            "The only way to do great work is to love what you do. - Steve Jobs",
+            "Believe you can and you're halfway there. - Theodore Roosevelt",
+            "The future belongs to those who believe in the beauty of their dreams. - Eleanor Roosevelt",
+            "Strive not to be a success, but rather to be of value. - Albert Einstein",
+            "The only limit to our realization of tomorrow will be our doubts of today. - Franklin D. Roosevelt"
+        ]
+        random_quote = random.choice(quotes)
+        st.sidebar.success(random_quote)
+
+    # Chat Export
+    st.sidebar.markdown("---")
+    if st.sidebar.button("Export Chat History"):
+        chat_history = "\n".join([f"{msg['role']}: {msg['content']}" for msg in st.session_state.messages])
+        st.sidebar.download_button(
+            label="Download Chat History",
+            data=chat_history,
+            file_name="ai_buddy_chat_history.txt",
+            mime="text/plain"
+        )
+        st.sidebar.success("Chat history ready for download!")
+
+if __name__ == "__main__":
+    main()

pages/chatbot.py

@@ -0,0 +1,242 @@
+import streamlit as st
+import random
+from langchain.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+from langchain.document_loaders import TextLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+import os
+from dotenv import load_dotenv
+import requests
+from bs4 import BeautifulSoup
+import pandas as pd
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+import time
+from langchain.schema import Document
+from docx import Document as DocxDocument
+from PyPDF2 import PdfReader
+import io
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = "api71-api-92fc2ef9-9f3c-47e5-a019-18e257b04af2"
+
+# Initialize session state variables
+if "custom_personality" not in st.session_state:
+    st.session_state.custom_personality = ""
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Initialize the Falcon model
+@st.cache_resource
+def get_llm():
+    return ChatOpenAI(
+        model="tiiuae/falcon-180B-chat",
+        api_key=AI71_API_KEY,
+        base_url=AI71_BASE_URL,
+        streaming=True,
+    )
+
+# Initialize embeddings
+@st.cache_resource
+def get_embeddings():
+    return HuggingFaceEmbeddings()
+
+def process_documents(uploaded_files):
+    documents = []
+    for uploaded_file in uploaded_files:
+        file_extension = os.path.splitext(uploaded_file.name)[1].lower()
+        try:
+            if file_extension in [".txt", ".md"]:
+                content = uploaded_file.getvalue().decode("utf-8")
+                documents.append(Document(page_content=content, metadata={"source": uploaded_file.name}))
+            elif file_extension == ".docx":
+                docx_file = io.BytesIO(uploaded_file.getvalue())
+                doc = DocxDocument(docx_file)
+                content = "\n".join([para.text for para in doc.paragraphs])
+                documents.append(Document(page_content=content, metadata={"source": uploaded_file.name}))
+            elif file_extension == ".pdf":
+                pdf_file = io.BytesIO(uploaded_file.getvalue())
+                pdf_reader = PdfReader(pdf_file)
+                content = ""
+                for page in pdf_reader.pages:
+                    content += page.extract_text()
+                documents.append(Document(page_content=content, metadata={"source": uploaded_file.name}))
+            else:
+                st.warning(f"Unsupported file type: {file_extension}")
+        except Exception as e:
+            st.error(f"Error processing file {uploaded_file.name}: {str(e)}")
+    
+    if not documents:
+        return None
+    
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    texts = text_splitter.split_documents(documents)
+    
+    vectorstore = FAISS.from_documents(texts, get_embeddings())
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
+    
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=get_llm(),
+        chain_type="stuff",
+        retriever=retriever,
+        return_source_documents=True,
+    )
+    
+    return qa_chain
+
+def get_chatbot_response(user_input, qa_chain=None, personality="default", web_search=False):
+    system_message = get_personality_prompt(personality)
+    
+    web_info = ""
+    if web_search:
+        web_results = search_web_duckduckgo(user_input)
+        web_info = "\n\n".join([f"Title: {result['title']}\nLink: {result['link']}\nSnippet: {result['snippet']}" for result in web_results])
+        user_input += f"\n\nWeb search results:\n{web_info}"
+    
+    if qa_chain:
+        result = qa_chain({"query": user_input})
+        response = result['result']
+        source_docs = result.get('source_documents', [])
+    else:
+        messages = [
+            SystemMessage(content=system_message),
+            HumanMessage(content=user_input)
+        ]
+        response = get_llm().invoke(messages).content
+        source_docs = []
+    
+    return response, source_docs, web_results if web_search else None
+
+def get_personality_prompt(personality):
+    personalities = {
+        "default": "You are a helpful assistant.",
+        "sherlock": "You are Sherlock Holmes, the world's greatest detective. Respond with keen observation and deductive reasoning.",
+        "yoda": "Wise and cryptic, you are. Like Yoda from Star Wars, speak you must.",
+        "shakespeare": "Thou art the Bard himself. In iambic pentameter, respond with eloquence and poetic flair.",
+        "custom": st.session_state.custom_personality
+    }
+    return personalities.get(personality, personalities["default"])
+
+def search_web_duckduckgo(query: str, num_results: int = 3, max_retries: int = 3):
+    api_key = "AIzaSyD-1OMuZ0CxGAek0PaXrzHOmcDWFvZQtm8"
+    cse_id = "877170db56f5c4629"
+    
+    for attempt in range(max_retries):
+        try:
+            service = build("customsearch", "v1", developerKey=api_key)
+            res = service.cse().list(q=query, cx=cse_id, num=num_results).execute()
+            results = []
+            if "items" in res:
+                for item in res["items"]:
+                    result = {
+                        "title": item["title"],
+                        "link": item["link"],
+                        "snippet": item.get("snippet", "")
+                    }
+                    results.append(result)
+            return results
+        except HttpError as e:
+            print(f"HTTP error occurred: {e}. Attempt {attempt + 1} of {max_retries}")
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}. Attempt {attempt + 1} of {max_retries}")
+        time.sleep(2 ** attempt)
+    print("Max retries reached. No results found.")
+    return []
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. Chatbot", page_icon="🕵️", layout="wide")
+    
+    st.title("S.H.E.R.L.O.C.K. Chatbot")
+    
+    # Sidebar
+    with st.sidebar:
+        st.image("data:image/jpeg;base64,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", use_column_width=True)
+        
+        st.subheader("📁 Document Upload")
+        uploaded_files = st.file_uploader("Upload documents", type=["txt", "md", "docx", "pdf"], accept_multiple_files=True)
+        
+        st.subheader("🎭 Chatbot Personality")
+        personality = st.selectbox("Choose chatbot personality", ["default", "sherlock", "yoda", "shakespeare", "custom"])
+        
+        if personality == "custom":
+            st.session_state.custom_personality = st.text_area("Enter custom personality details:", value=st.session_state.custom_personality)
+        
+        st.subheader("🌐 Web Search")
+        web_search = st.checkbox("Enable web search")
+        
+        st.subheader("💬 Chat Mode")
+        chat_mode = st.radio("Select chat mode", ["General Chat", "Document Chat"])
+        
+        if st.button("Clear Chat History"):
+            st.session_state.messages = []
+            st.rerun()
+
+    # Main content
+    if uploaded_files:
+        qa_chain = process_documents(uploaded_files)
+        if qa_chain:
+            st.success("Documents processed successfully!")
+        else:
+            st.warning("No valid documents were uploaded or processed.")
+    else:
+        qa_chain = None
+
+    # Chat interface
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+    if prompt := st.chat_input("What is your question?"):
+        st.chat_message("user").markdown(prompt)
+        st.session_state.messages.append({"role": "user", "content": prompt})
+
+        if chat_mode == "General Chat" or not qa_chain:
+            response, _, web_results = get_chatbot_response(prompt, personality=personality, web_search=web_search)
+        else:
+            response, source_docs, web_results = get_chatbot_response(prompt, qa_chain, personality, web_search)
+        
+        with st.chat_message("assistant"):
+            st.markdown(response)
+            if chat_mode == "Document Chat" and qa_chain and source_docs:
+                with st.expander("Source Documents"):
+                    for doc in source_docs:
+                        st.markdown(f"**Source:** {doc.metadata.get('source', 'Unknown')}")
+                        st.markdown(doc.page_content[:200] + "...")
+            
+            if web_search and web_results:
+                with st.expander("Web Search Results"):
+                    for result in web_results:
+                        st.markdown(f"**[{result['title']}]({result['link']})**")
+                        st.markdown(result['snippet'])
+        
+        st.session_state.messages.append({"role": "assistant", "content": response})
+
+    # Chat history and download
+    with st.sidebar:
+        st.subheader("📜 Chat History")
+        history_expander = st.expander("View Chat History")
+        with history_expander:
+            for message in st.session_state.messages:
+                st.text(f"{message['role']}: {message['content'][:50]}...")
+        
+        if st.session_state.messages:
+            chat_history_df = pd.DataFrame(st.session_state.messages)
+            csv = chat_history_df.to_csv(index=False)
+            st.download_button(
+                label="📥 Download Chat History",
+                data=csv,
+                file_name="chat_history.csv",
+                mime="text/csv",
+            )
+
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("Powered by Falcon-180B and Streamlit")
+
+if __name__ == "__main__":
+    main()

pages/exam_prepration.py

@@ -0,0 +1,325 @@
+import streamlit as st
+import random
+import time
+from typing import List, Dict
+from langchain_openai import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+from langchain_community.document_loaders import PyPDFLoader, TextLoader, UnstructuredWordDocumentLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+from langchain_community.graphs import NetworkxEntityGraph
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+import os
+from dotenv import load_dotenv
+import requests
+from bs4 import BeautifulSoup
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = "api71-api-92fc2ef9-9f3c-47e5-a019-18e257b04af2"
+GOOGLE_API_KEY = "AIzaSyD-1OMuZ0CxGAek0PaXrzHOmcDWFvZQtm8"
+GOOGLE_CSE_ID = "877170db56f5c4629"
+YOUTUBE_API_KEY = "AIzaSyD-1OMuZ0CxGAek0PaXrzHOmcDWFvZQtm8"
+
+# Initialize the Falcon model
+chat = ChatOpenAI(
+    model="tiiuae/falcon-180B-chat",
+    api_key=AI71_API_KEY,
+    base_url=AI71_BASE_URL,
+    streaming=True,
+)
+
+# Initialize embeddings
+embeddings = HuggingFaceEmbeddings()
+
+FIELDS = [
+    "Mathematics", "Physics", "Chemistry", "Biology", "Computer Science",
+    "History", "Geography", "Literature", "Philosophy", "Psychology",
+    "Sociology", "Economics", "Business", "Finance", "Accounting",
+    "Law", "Political Science", "Environmental Science", "Astronomy", "Geology",
+    "Linguistics", "Anthropology", "Art History", "Music Theory", "Film Studies",
+    "Medical Science", "Nursing", "Public Health", "Nutrition", "Physical Education",
+    "Engineering", "Architecture", "Urban Planning", "Agriculture", "Veterinary Science",
+    "Oceanography", "Meteorology", "Statistics", "Data Science", "Artificial Intelligence",
+    "Cybersecurity", "Renewable Energy", "Quantum Physics", "Neuroscience", "Genetics",
+    "Biotechnology", "Nanotechnology", "Robotics", "Space Exploration", "Cryptography"
+]
+
+# List of educational resources
+EDUCATIONAL_RESOURCES = [
+    "https://www.coursera.org",
+    "https://www.khanacademy.org",
+    "https://scholar.google.com",
+    "https://www.edx.org",
+    "https://www.udacity.com",
+    "https://www.udemy.com",
+    "https://www.futurelearn.com",
+    "https://www.lynda.com",
+    "https://www.skillshare.com",
+    "https://www.codecademy.com",
+    "https://www.brilliant.org",
+    "https://www.duolingo.com",
+    "https://www.ted.com/talks",
+    "https://ocw.mit.edu",
+    "https://www.open.edu/openlearn",
+    "https://www.coursebuffet.com",
+    "https://www.academicearth.org",
+    "https://www.edutopia.org",
+    "https://www.saylor.org",
+    "https://www.openculture.com",
+    "https://www.gutenberg.org",
+    "https://www.archive.org",
+    "https://www.wolframalpha.com",
+    "https://www.quizlet.com",
+    "https://www.mathway.com",
+    "https://www.symbolab.com",
+    "https://www.lessonplanet.com",
+    "https://www.teacherspayteachers.com",
+    "https://www.brainpop.com",
+    "https://www.ck12.org"
+]
+
+def search_web(query: str, num_results: int = 30, max_retries: int = 3) -> List[Dict[str, str]]:
+    user_agents = [
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Safari/537.36'
+    ]
+    
+    for attempt in range(max_retries):
+        try:
+            headers = {'User-Agent': random.choice(user_agents)}
+            service = build("customsearch", "v1", developerKey=GOOGLE_API_KEY)
+            res = service.cse().list(q=query, cx=GOOGLE_CSE_ID, num=num_results).execute()
+            
+            results = []
+            if "items" in res:
+                for item in res["items"]:
+                    result = {
+                        "title": item["title"],
+                        "link": item["link"],
+                        "snippet": item.get("snippet", "")
+                    }
+                    results.append(result)
+            
+            return results
+        except Exception as e:
+            print(f"An error occurred: {e}. Attempt {attempt + 1} of {max_retries}")
+            time.sleep(2 ** attempt)
+    
+    print("Max retries reached. No results found.")
+    return []
+
+def scrape_webpage(url: str) -> str:
+    try:
+        response = requests.get(url, timeout=10)
+        soup = BeautifulSoup(response.content, 'html.parser')
+        return soup.get_text()
+    except Exception as e:
+        print(f"Error scraping {url}: {e}")
+        return ""
+
+def process_documents(uploaded_files):
+    documents = []
+    for uploaded_file in uploaded_files:
+        file_extension = os.path.splitext(uploaded_file.name)[1].lower()
+        
+        if file_extension == '.pdf':
+            loader = PyPDFLoader(uploaded_file)
+        elif file_extension in ['.txt', '.md']:
+            loader = TextLoader(uploaded_file)
+        elif file_extension in ['.doc', '.docx']:
+            loader = UnstructuredWordDocumentLoader(uploaded_file)
+        else:
+            st.warning(f"Unsupported file type: {file_extension}")
+            continue
+        
+        documents.extend(loader.load())
+    
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    texts = text_splitter.split_documents(documents)
+    
+    vectorstore = FAISS.from_documents(texts, embeddings)
+    graph = NetworkxEntityGraph()
+    graph.add_documents(texts)
+    
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+    
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=chat,
+        chain_type="stuff",
+        retriever=retriever,
+        return_source_documents=True
+    )
+    
+    return qa_chain, graph
+
+def generate_questions(topic, difficulty, num_questions, include_answers, qa_chain=None, graph=None):
+    system_prompt = f"""You are an expert exam question generator. Generate {num_questions} {difficulty}-level questions about {topic}. 
+    {"Each question should be followed by its correct answer." if include_answers else "Do not include answers."}
+    Format your response as follows:
+
+    Q1. [Question]
+    {"A1. [Answer]" if include_answers else ""}
+
+    Q2. [Question]
+    {"A2. [Answer]" if include_answers else ""}
+
+    ... and so on.
+    """
+    
+    if qa_chain and graph:
+        context = graph.get_relevant_documents(topic)
+        context_text = "\n".join([doc.page_content for doc in context])
+        
+        result = qa_chain({"query": system_prompt, "context": context_text})
+        questions = result['result']
+    else:
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=f"Please generate {num_questions} {difficulty} questions about {topic}.")
+        ]
+        questions = chat(messages).content
+    
+    return questions
+
+def gather_resources(field: str) -> List[Dict[str, str]]:
+    resources = []
+    for resource_url in EDUCATIONAL_RESOURCES:
+        search_results = search_web(f"site:{resource_url} {field}", num_results=1)
+        if search_results:
+            result = search_results[0]
+            content = scrape_webpage(result['link'])
+            resources.append({
+                "title": result['title'],
+                "link": result['link'],
+                "content": content[:500] + "..." if len(content) > 500 else content
+            })
+    
+    # YouTube search
+    youtube = build('youtube', 'v3', developerKey=YOUTUBE_API_KEY)
+    youtube_results = youtube.search().list(q=field, type='video', part='id,snippet', maxResults=5).execute()
+    for item in youtube_results.get('items', []):
+        video_id = item['id']['videoId']
+        resources.append({
+            "title": item['snippet']['title'],
+            "link": f"https://www.youtube.com/watch?v={video_id}",
+            "content": item['snippet']['description'],
+            "thumbnail": item['snippet']['thumbnails']['medium']['url']
+        })
+    
+    return resources
+
+def main():
+    st.set_page_config(page_title="Advanced Exam Preparation System", layout="wide")
+    
+    st.sidebar.title("Advanced Exam Prep")
+    st.sidebar.markdown("""
+    Welcome to our advanced exam preparation system! 
+    Here you can generate practice questions, explore educational resources, 
+    and interact with an AI tutor to enhance your learning experience.
+    """)
+    
+    # Main area tabs
+    tab1, tab2, tab3 = st.tabs(["Question Generator", "Resource Explorer", "Academic Tutor"])
+    
+    with tab1:
+        st.header("Question Generator")
+        col1, col2 = st.columns(2)
+        with col1:
+            topic = st.text_input("Enter the exam topic:")
+            exam_type = st.selectbox("Select exam type:", ["General", "STEM", "Humanities", "Business", "Custom"])
+        with col2:
+            difficulty = st.select_slider(
+                "Select difficulty level:",
+                options=["Super Easy", "Easy", "Beginner", "Intermediate", "Higher Intermediate", "Master", "Advanced"]
+            )
+            num_questions = st.number_input("Number of questions:", min_value=1, max_value=50, value=5)
+        include_answers = st.checkbox("Include answers", value=True)
+        
+        if st.button("Generate Questions", key="generate_questions"):
+            if topic:
+                with st.spinner("Generating questions..."):
+                    questions = generate_questions(topic, difficulty, num_questions, include_answers)
+                st.success("Questions generated successfully!")
+                st.markdown(questions)
+            else:
+                st.warning("Please enter a topic.")
+    
+    with tab2:
+        st.header("Resource Explorer")
+        selected_field = st.selectbox("Select a field to explore:", FIELDS)
+        if st.button("Explore Resources", key="explore_resources"):
+            with st.spinner("Gathering resources..."):
+                resources = gather_resources(selected_field)
+            st.success(f"Found {len(resources)} resources!")
+            
+            for i, resource in enumerate(resources):
+                col1, col2 = st.columns([1, 3])
+                with col1:
+                    if "thumbnail" in resource:
+                        st.image(resource["thumbnail"], use_column_width=True)
+                    else:
+                        st.image("https://via.placeholder.com/150", use_column_width=True)
+                with col2:
+                    st.subheader(f"[{resource['title']}]({resource['link']})")
+                    st.write(resource['content'])
+                st.markdown("---")
+    
+    with tab3:
+        st.header("Academic Tutor")
+        uploaded_files = st.file_uploader("Upload documents (PDF, TXT, MD, DOC, DOCX)", type=["pdf", "txt", "md", "doc", "docx"], accept_multiple_files=True)
+        
+        if uploaded_files:
+            qa_chain, graph = process_documents(uploaded_files)
+            st.success("Documents processed successfully!")
+        else:
+            qa_chain, graph = None, None
+        
+        st.subheader("Chat with AI Tutor")
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = []
+
+        chat_container = st.container()
+        with chat_container:
+            for i, (role, message) in enumerate(st.session_state.chat_history):
+                with st.chat_message(role):
+                    st.write(message)
+
+        user_input = st.chat_input("Ask a question or type 'search: your query' to perform a web search:")
+        if user_input:
+            st.session_state.chat_history.append(("user", user_input))
+            with st.chat_message("user"):
+                st.write(user_input)
+
+            with st.chat_message("assistant"):
+                if user_input.lower().startswith("search:"):
+                    search_query = user_input[7:].strip()
+                    search_results = search_web(search_query, num_results=3)
+                    response = f"Here are some search results for '{search_query}':\n\n"
+                    for result in search_results:
+                        response += f"- [{result['title']}]({result['link']})\n  {result['snippet']}\n\n"
+                else:
+                    response = chat([HumanMessage(content=user_input)]).content
+                st.write(response)
+                st.session_state.chat_history.append(("assistant", response))
+
+        # Scroll to bottom of chat
+        js = f"""
+        <script>
+            function scroll_to_bottom() {{
+                var chatElement = window.parent.document.querySelector('.stChatFloatingInputContainer');
+                chatElement.scrollIntoView({{behavior: 'smooth'}});
+            }}
+            scroll_to_bottom();
+        </script>
+        """
+        st.components.v1.html(js)
+
+if __name__ == "__main__":
+    main()

pages/interview_prepration.py

@@ -0,0 +1,560 @@
+import streamlit as st
+import random
+from langchain_community.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+import os
+from dotenv import load_dotenv
+import base64
+import cv2
+import numpy as np
+from PIL import Image
+import io
+import time
+import PyPDF2
+import docx
+import markdown
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = "api71-api-92fc2ef9-9f3c-47e5-a019-18e257b04af2"
+
+# Initialize the Falcon model
+chat = ChatOpenAI(
+    model="tiiuae/falcon-180B-chat",
+    api_key=AI71_API_KEY,
+    base_url=AI71_BASE_URL,
+    streaming=True,
+    timeout=60,
+)
+
+# Expanded list of roles
+roles = [
+    "Software Engineer", "Data Scientist", "Product Manager", "UX Designer", "Marketing Manager",
+    "Sales Representative", "Human Resources Manager", "Financial Analyst", "Project Manager",
+    "Business Analyst", "Content Writer", "Graphic Designer", "Customer Service Representative",
+    "Operations Manager", "Research Scientist", "Legal Counsel", "Network Administrator",
+    "Quality Assurance Tester", "Supply Chain Manager", "Public Relations Specialist"
+]
+
+def generate_interview_questions(role):
+    system_message = f"""You are an experienced interviewer for the role of {role}. 
+    Generate 5 challenging and relevant interview questions for this position. 
+    The questions should cover a range of skills and experiences required for the role."""
+
+    messages = [
+        SystemMessage(content=system_message),
+        HumanMessage(content="Please provide 5 interview questions for this role.")
+    ]
+
+    response = chat.invoke(messages).content
+    questions = response.split('\n')
+    return [q.strip() for q in questions if q.strip()]
+
+def get_interview_response(role, question, answer):
+    system_message = f"""You are an experienced interviewer for the role of {role}. 
+    Your task is to evaluate the candidate's response to the following question: '{question}'
+    
+    The candidate's answer was: '{answer}'
+    
+    Please provide:
+    1. A brief evaluation of the answer (2-3 sentences)
+    2. Specific feedback on how to improve (if needed) or praise for a good answer
+    3. A follow-up question based on their response
+    4. A score out of 10 for their answer
+    
+    Format your response as follows:
+    Evaluation: [Your evaluation here]
+    Feedback: [Your specific feedback or praise here]
+    Follow-up: [Your follow-up question here]
+    Score: [Score out of 10]
+    """
+
+    messages = [
+        SystemMessage(content=system_message),
+        HumanMessage(content="Please provide your evaluation, feedback, follow-up question, and score.")
+    ]
+
+    response = chat.invoke(messages).content
+    return response
+
+def analyze_appearance(image):
+    # Convert PIL Image to OpenCV format
+    cv_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+    
+    # Load pre-trained face detection model
+    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+    
+    # Convert to grayscale for face detection
+    gray = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
+    
+    # Detect faces
+    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
+    
+    analysis = []
+    
+    if len(faces) == 0:
+        analysis.append("No face detected in the image. Please ensure your face is clearly visible.")
+    else:
+        analysis.append(f"Detected {len(faces)} face(s) in the image.")
+        
+        # Analyze facial positioning
+        for (x, y, w, h) in faces:
+            face_center = (x + w//2, y + h//2)
+            image_center = (cv_image.shape[1]//2, cv_image.shape[0]//2)
+            
+            if abs(face_center[0] - image_center[0]) > cv_image.shape[1]//8:
+                analysis.append("Your face is not centered horizontally. Try to position yourself in the middle of the frame.")
+            
+            if abs(face_center[1] - image_center[1]) > cv_image.shape[0]//8:
+                analysis.append("Your face is not centered vertically. Adjust your camera or seating position.")
+            
+            if w * h < (cv_image.shape[0] * cv_image.shape[1]) // 16:
+                analysis.append("Your face appears too small in the frame. Consider moving closer to the camera.")
+            elif w * h > (cv_image.shape[0] * cv_image.shape[1]) // 4:
+                analysis.append("Your face appears too large in the frame. Consider moving slightly away from the camera.")
+    
+    # Analyze image brightness
+    brightness = np.mean(gray)
+    if brightness < 100:
+        analysis.append("The image appears too dark. Consider improving your lighting for better visibility.")
+    elif brightness > 200:
+        analysis.append("The image appears too bright. You might want to reduce harsh lighting or adjust your camera settings.")
+    
+    # Analyze image contrast
+    contrast = np.std(gray)
+    if contrast < 20:
+        analysis.append("The image lacks contrast. This might make it difficult to see details. Consider adjusting your lighting or camera settings.")
+    
+    return "\n".join(analysis)
+
+def extract_text_from_file(file):
+    file_extension = file.name.split('.')[-1].lower()
+    
+    if file_extension == 'pdf':
+        pdf_reader = PyPDF2.PdfReader(file)
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text()
+    elif file_extension == 'docx':
+        doc = docx.Document(file)
+        text = "\n".join([paragraph.text for paragraph in doc.paragraphs])
+    elif file_extension == 'txt':
+        text = file.read().decode()
+    elif file_extension == 'md':
+        md_text = file.read().decode()
+        text = markdown.markdown(md_text)
+    else:
+        raise ValueError(f"Unsupported file format: {file_extension}")
+    
+    return text
+
+def analyze_cv(cv_text):
+    system_message = """You are an expert CV reviewer with extensive experience in various industries. 
+    Analyze the given CV and provide:
+    1. An overall assessment of the CV's strengths
+    2. Areas that need improvement
+    3. Specific suggestions for enhancing the CV
+    4. Tips for tailoring the CV to specific job applications
+
+    Be thorough, constructive, and provide actionable advice."""
+
+    messages = [
+        SystemMessage(content=system_message),
+        HumanMessage(content=f"Here's the text of the CV to review:\n\n{cv_text}\n\nPlease provide your analysis and suggestions.")
+    ]
+
+    response = chat.invoke(messages).content
+    return response
+
+def resize_image(image, max_size=800):
+    """Resize image while maintaining aspect ratio"""
+    ratio = max_size / max(image.size)
+    new_size = tuple([int(x*ratio) for x in image.size])
+    return image.resize(new_size, Image.LANCZOS)
+
+def get_mock_interview_tips():
+    tips = [
+        "Research the company and role thoroughly before the interview.",
+        "Practice common interview questions with a friend or family member.",
+        "Prepare specific examples to illustrate your skills and experiences.",
+        "Dress professionally and ensure your background is tidy for video interviews.",
+        "Have questions prepared to ask the interviewer about the role and company.",
+        "Use the STAR method (Situation, Task, Action, Result) to structure your answers.",
+        "Be aware of your body language and maintain good eye contact.",
+        "Listen carefully to each question and take a moment to gather your thoughts before answering.",
+        "Be honest about your experiences and skills, but focus on your strengths.",
+        "Follow up with a thank-you note or email after the interview.",
+    ]
+    return tips
+
+def get_interview_resources():
+    resources = [
+        {"name": "Glassdoor Interview Questions & Reviews", "url": "https://www.glassdoor.com/Interview/index.htm"},
+        {"name": "LinkedIn Interview Preparation", "url": "https://www.linkedin.com/interview-prep/"},
+        {"name": "Indeed Career Guide", "url": "https://www.indeed.com/career-advice"},
+        {"name": "Coursera - How to Succeed in an Interview", "url": "https://www.coursera.org/learn/interview-preparation"},
+        {"name": "Harvard Business Review - Interview Tips", "url": "https://hbr.org/topic/interviewing"},
+    ]
+    return resources
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. Interview Preparation", page_icon="🎙️", layout="wide")
+
+    st.title("🎙️ S.H.E.R.L.O.C.K. Interview Preparation")
+    st.markdown("### Streamlined Help for Enhancing Responsive Learning and Optimizing Career Knowledge")
+
+    # Sidebar for user details and interview settings
+    with st.sidebar:
+        st.header("Interview Settings")
+        name = st.text_input("Your Name")
+        role = st.selectbox("Interview Role", roles)
+        experience = st.slider("Years of Experience", 0, 20, 5)
+
+        st.header("Quick Tips")
+        if st.button("Get Mock Interview Tips"):
+            tips = get_mock_interview_tips()
+            for tip in tips:
+                st.info(tip)
+
+        st.header("Useful Resources")
+        resources = get_interview_resources()
+        for resource in resources:
+            st.markdown(f"[{resource['name']}]({resource['url']})")
+
+    # Appearance Analysis
+    st.header("Appearance Analysis")
+    uploaded_image = st.file_uploader("Upload your interview outfit image", type=["jpg", "jpeg", "png"])
+    if uploaded_image is not None:
+        try:
+            image = Image.open(uploaded_image)
+            image = resize_image(image)
+            st.image(image, caption="Your uploaded image", use_column_width=True)
+            if st.button("Analyze Appearance"):
+                with st.spinner("Analyzing your appearance..."):
+                    appearance_feedback = analyze_appearance(image)
+                    st.write(appearance_feedback)
+                    
+                    st.write("\nGeneral tips for professional appearance in video interviews:")
+                    tips = [
+                        "Dress professionally from head to toe, even if only your upper body is visible.",
+                        "Choose solid colors over busy patterns for a less distracting appearance.",
+                        "Ensure your background is tidy and professional.",
+                        "Position your camera at eye level for the most flattering angle.",
+                        "Use soft, diffused lighting to avoid harsh shadows.",
+                        "Make eye contact by looking directly into the camera when speaking.",
+                    ]
+                    for tip in tips:
+                        st.write(f"- {tip}")
+        except Exception as e:
+            st.error(f"An error occurred while processing the image: {str(e)}")
+            st.info("Please make sure you've uploaded a valid image file.")
+
+    # CV Analysis
+    st.header("CV Analysis")
+    uploaded_cv = st.file_uploader("Upload your CV", type=["pdf", "docx", "txt", "md"])
+    if uploaded_cv is not None:
+        try:
+            cv_text = extract_text_from_file(uploaded_cv)
+            if st.button("Analyze CV"):
+                with st.spinner("Analyzing your CV..."):
+                    cv_feedback = analyze_cv(cv_text)
+                st.write(cv_feedback)
+        except Exception as e:
+            st.error(f"An error occurred while processing the CV: {str(e)}")
+
+    # Initialize session state variables
+    if 'interview_started' not in st.session_state:
+        st.session_state.interview_started = False
+    if 'current_question' not in st.session_state:
+        st.session_state.current_question = 0
+    if 'questions' not in st.session_state:
+        st.session_state.questions = []
+    if 'answers' not in st.session_state:
+        st.session_state.answers = []
+    if 'feedback' not in st.session_state:
+        st.session_state.feedback = []
+    if 'scores' not in st.session_state:
+        st.session_state.scores = []
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+
+    # Start Interview button
+    if not st.session_state.interview_started:
+        if st.button("Start Mock Interview"):
+            if name and role:
+                st.session_state.interview_started = True
+                with st.spinner("Generating interview questions..."):
+                    st.session_state.questions = generate_interview_questions(role)
+                st.rerun()
+            else:
+                st.warning("Please enter your name and select a role before starting the interview.")
+
+    # Interview in progress
+    if st.session_state.interview_started:
+        st.header("Mock Interview")
+        if st.session_state.current_question < len(st.session_state.questions):
+            st.subheader(f"Question {st.session_state.current_question + 1}")
+            st.write(st.session_state.questions[st.session_state.current_question])
+
+            # Display chat history
+            for i, (q, a, f) in enumerate(st.session_state.chat_history):
+                with st.expander(f"Question {i+1}"):
+                    st.write(f"Q: {q}")
+                    st.write(f"Your Answer: {a}")
+                    st.write(f"Feedback: {f}")
+
+            answer = st.text_area("Your Answer", key=f"answer_{st.session_state.current_question}")
+
+            col1, col2 = st.columns(2)
+            with col1:
+                if st.button("Submit Answer"):
+                    if answer:
+                        with st.spinner("Evaluating your answer..."):
+                            response = get_interview_response(role, st.session_state.questions[st.session_state.current_question], answer)
+                            st.session_state.answers.append(answer)
+                            st.session_state.feedback.append(response)
+                            
+                            # Extract score from response
+                            score_lines = [line for line in response.split('\n') if line.startswith('Score:')]
+                            if score_lines:
+                                score_str = score_lines[0].split(':')[1].strip()
+                                try:
+                                    score = int(score_str)
+                                except ValueError:
+                                    # If the score is a fraction like "6/10", extract the numerator
+                                    score = int(score_str.split('/')[0])
+                            else:
+                                # If no score is found, use a default value
+                                score = 5  # or any other default value you prefer
+                                st.warning("No score was provided in the response. Using a default score of 5.")
+                            
+                            st.session_state.scores.append(score)
+
+                            # Update chat history
+                            st.session_state.chat_history.append((
+                                st.session_state.questions[st.session_state.current_question],
+                                answer,
+                                response
+                            ))
+
+                        st.session_state.current_question += 1
+                        if st.session_state.current_question < len(st.session_state.questions):
+                            st.rerun()
+                    else:
+                        st.warning("Please provide an answer before submitting.")
+            with col2:
+                if st.button("Skip Question"):
+                    st.session_state.current_question += 1
+                    if st.session_state.current_question < len(st.session_state.questions):
+                        st.rerun()
+
+        else:
+            st.success("Interview Completed!")
+            total_score = sum(st.session_state.scores)
+            average_score = total_score / len(st.session_state.scores)
+
+            st.header("Interview Summary")
+            st.subheader(f"Overall Score: {average_score:.2f}/10")
+
+            for i, (q, a, f) in enumerate(st.session_state.chat_history):
+                with st.expander(f"Question {i+1}"):
+                    st.write(f"Q: {q}")
+                    st.write(f"Your Answer: {a}")
+                    st.write(f"Feedback: {f}")
+
+            # Generate overall feedback
+            overall_feedback_prompt = f"""
+            You are an experienced career coach. Based on the candidate's performance in the interview for the role of {role},
+            with {experience} years of experience, please provide:
+            1. A summary of their strengths (2-3 points)
+            2. Areas for improvement (2-3 points)
+            3. Advice for future interviews (2-3 tips)
+            4. Personalized tips for improving their professional appearance and body language
+            5. Strategies for managing interview anxiety
+
+            Their overall score was {average_score:.2f}/10.
+
+            Format your response as follows:
+            Strengths:
+            - [Strength 1]
+            - [Strength 2]
+            - [Strength 3]
+
+            Areas for Improvement:
+            - [Area 1]
+            - [Area 2]
+            - [Area 3]
+
+            Tips for Future Interviews:
+            - [Tip 1]
+            - [Tip 2]
+            - [Tip 3]
+
+            Professional Appearance and Body Language:
+            - [Tip 1]
+            - [Tip 2]
+            - [Tip 3]
+
+            Managing Interview Anxiety:
+            - [Strategy 1]
+            - [Strategy 2]
+            - [Strategy 3]
+            """
+
+            messages = [
+                SystemMessage(content=overall_feedback_prompt),
+                HumanMessage(content="Please provide the overall feedback for the interview.")
+            ]
+
+            with st.spinner("Generating overall feedback..."):
+                overall_feedback = chat.invoke(messages).content
+
+            st.subheader("Overall Feedback")
+            st.write(overall_feedback)
+
+            if st.button("Start New Interview"):
+                st.session_state.interview_started = False
+                st.session_state.current_question = 0
+                st.session_state.questions = []
+                st.session_state.answers = []
+                st.session_state.feedback = []
+                st.session_state.scores = []
+                st.session_state.chat_history = []
+                st.rerun()
+
+    # Footer
+    st.markdown("---")
+    st.markdown("Powered by Falcon-180B and Streamlit")
+
+    # Interview Preparation Checklist
+    st.sidebar.header("Interview Preparation Checklist")
+    checklist_items = [
+        "Research the company",
+        "Review the job description",
+        "Prepare your elevator pitch",
+        "Practice common interview questions",
+        "Prepare questions for the interviewer",
+        "Choose appropriate attire",
+        "Test your technology (for virtual interviews)",
+        "Gather necessary documents (resume, portfolio, etc.)",
+        "Plan your route or set up your interview space",
+        "Get a good night's sleep"
+    ]
+    for item in checklist_items:
+        st.sidebar.checkbox(item)
+
+    # Interview Timer
+    if st.session_state.interview_started:
+        st.sidebar.header("Interview Timer")
+        if 'start_time' not in st.session_state:
+            st.session_state.start_time = time.time()
+        
+        elapsed_time = int(time.time() - st.session_state.start_time)
+        minutes, seconds = divmod(elapsed_time, 60)
+        st.sidebar.write(f"Elapsed Time: {minutes:02d}:{seconds:02d}")
+
+    # Confidence Boost
+    st.sidebar.header("Confidence Boost")
+    if st.sidebar.button("Get a Confidence Boost"):
+        confidence_boosters = [
+            "You've got this! Your preparation will pay off.",
+            "Remember, the interviewer wants you to succeed too.",
+            "Take deep breaths and stay calm. You're well-prepared.",
+            "Your unique experiences make you a valuable candidate.",
+            "Every interview is a learning opportunity. Embrace it!",
+            "Believe in yourself. Your skills and knowledge are valuable.",
+            "Stay positive and confident. Your attitude shines through.",
+            "You've overcome challenges before. This is just another opportunity to shine.",
+            "Focus on your strengths and what you can bring to the role.",
+            "Remember your past successes. You're capable of greatness!"
+        ]
+        st.sidebar.success(random.choice(confidence_boosters))
+
+    # Interview Do's and Don'ts
+    st.sidebar.header("Interview Do's and Don'ts")
+    dos_and_donts = {
+        "Do": [
+            "Arrive early or log in on time",
+            "Maintain good eye contact",
+            "Listen actively and ask thoughtful questions",
+            "Show enthusiasm for the role and company",
+            "Provide specific examples to support your answers"
+        ],
+        "Don't": [
+            "Speak negatively about past employers",
+            "Interrupt the interviewer",
+            "Use filler words excessively (um, like, you know)",
+            "Check your phone or watch frequently",
+            "Provide vague or generic answers"
+        ]
+    }
+    dos_tab, donts_tab = st.sidebar.tabs(["Do's", "Don'ts"])
+    with dos_tab:
+        for do_item in dos_and_donts["Do"]:
+            st.write(f"✅ {do_item}")
+    with donts_tab:
+        for dont_item in dos_and_donts["Don't"]:
+            st.write(f"❌ {dont_item}")
+
+    # Personal Notes
+    st.sidebar.header("Personal Notes")
+    personal_notes = st.sidebar.text_area("Jot down your thoughts or reminders here:")
+
+    # Initialize session state for saved notes if it doesn't exist
+    if 'saved_notes' not in st.session_state:
+        st.session_state.saved_notes = []
+
+    # Save Notes button
+    if st.sidebar.button("Save Notes"):
+        if personal_notes.strip():  # Check if the note is not empty
+            st.session_state.saved_notes.append(personal_notes)
+            st.sidebar.success("Note saved successfully!")
+            # Clear the text area after saving
+            personal_notes = ""
+        else:
+            st.sidebar.warning("Please enter a note before saving.")
+
+    # Display saved notes as checkboxes
+    st.sidebar.subheader("Saved Notes")
+    for i, note in enumerate(st.session_state.saved_notes):
+        col1, col2 = st.sidebar.columns([3, 1])
+        with col1:
+            st.checkbox(note, key=f"note_{i}")
+        with col2:
+            if st.button("Delete", key=f"delete_{i}"):
+                del st.session_state.saved_notes[i]
+                st.rerun()
+                
+    # Follow-up Email Template
+    if st.session_state.interview_started and st.session_state.current_question >= len(st.session_state.questions):
+        st.header("Follow-up Email Template")
+        interviewer_name = st.text_input("Interviewer's Name")
+        company_name = st.text_input("Company Name")
+        specific_topic = st.text_input("Specific topic discussed during the interview")
+        
+        if interviewer_name and company_name and specific_topic:
+            email_template = f"""
+            Subject: Thank you for the interview - {role} position
+
+            Dear {interviewer_name},
+
+            I hope this email finds you well. I wanted to express my sincere gratitude for taking the time to interview me for the {role} position at {company_name}. I thoroughly enjoyed our conversation and learning more about the role and the company.
+
+            Our discussion about {specific_topic} was particularly interesting, and it reinforced my enthusiasm for the position. I am excited about the possibility of bringing my skills and experience to your team and contributing to {company_name}'s success.
+
+            If you need any additional information or have any further questions, please don't hesitate to contact me. I look forward to hearing about the next steps in the process.
+
+            Thank you again for your time and consideration.
+
+            Best regards,
+            {name}
+            """
+            st.text_area("Follow-up Email Template", email_template, height=300)
+            if st.button("Copy to Clipboard"):
+                st.write("Email template copied to clipboard!")
+                # Note: In a web app, you'd use JavaScript to copy to clipboard
+
+if __name__ == "__main__":
+    main()

pages/meditation.py

@@ -0,0 +1,130 @@
+import streamlit as st
+import time
+import random
+from pydub import AudioSegment
+from pydub.generators import Sine
+import io
+import base64
+
+# Function to generate binaural beats
+def generate_binaural_beat(freq1, freq2, duration_ms):
+    beat1 = Sine(freq1).to_audio_segment(duration=duration_ms)
+    beat2 = Sine(freq2).to_audio_segment(duration=duration_ms)
+    
+    stereo_beat = AudioSegment.from_mono_audiosegments(beat1, beat2)
+    
+    buffer = io.BytesIO()
+    stereo_beat.export(buffer, format="wav")
+    return buffer.getvalue()
+
+# Function to get binary audio data as base64
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    bin_str = base64.b64encode(bin_file).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{file_label}.wav">Download {file_label}</a>'
+    return href
+
+# Streamlit app
+def main():
+    st.set_page_config(page_title="Meditation & Mindfulness Hub", layout="wide")
+
+    st.title("🧘 Meditation & Mindfulness Hub")
+    st.markdown("Improve your mental health and focus with our holistic learning experience.")
+
+    # Sidebar for navigation
+    menu = st.sidebar.selectbox("Choose a Practice", ["Meditation", "Mindfulness Exercises", "Binaural Beats", "Positive Affirmations"])
+
+    if menu == "Meditation":
+        meditation_page()
+    elif menu == "Mindfulness Exercises":
+        mindfulness_page()
+    elif menu == "Binaural Beats":
+        binaural_beats_page()
+    elif menu == "Positive Affirmations":
+        affirmations_page()
+
+def meditation_page():
+    st.header("Guided Meditation")
+    
+    meditation_types = {
+        "Breath Awareness": "Focus on your breath, observing each inhale and exhale...",
+        "Body Scan": "Starting from your toes, gradually move your attention up through your body...",
+        "Loving-Kindness": "Direct feelings of love and compassion towards yourself and others...",
+        "Visualization": "Imagine a peaceful scene, like a serene beach or a tranquil forest..."
+    }
+    
+    selected_meditation = st.selectbox("Choose a meditation type:", list(meditation_types.keys()))
+    duration = st.slider("Meditation duration (minutes):", 5, 30, 10)
+    
+    if st.button("Start Meditation"):
+        with st.spinner(f"Meditating for {duration} minutes..."):
+            st.text(meditation_types[selected_meditation])
+            meditation_progress = st.progress(0)
+            for i in range(duration * 60):
+                time.sleep(1)
+                meditation_progress.progress((i + 1) / (duration * 60))
+        st.success("Meditation complete. How do you feel?")
+
+def mindfulness_exercises_page():
+    st.header("Mindfulness Exercises")
+    
+    exercises = [
+        "Take three deep breaths, focusing on the sensation of air entering and leaving your body.",
+        "Notice five things you can see, four things you can touch, three things you can hear, two things you can smell, and one thing you can taste.",
+        "Spend one minute focusing solely on the present moment, acknowledging thoughts without judgment.",
+        "Practice mindful walking by paying attention to each step and the sensations in your feet.",
+        "Eat a small snack mindfully, noticing the taste, texture, and aroma with each bite."
+    ]
+    
+    selected_exercise = st.selectbox("Choose a mindfulness exercise:", exercises)
+    
+    if st.button("Start Exercise"):
+        with st.spinner("Practicing mindfulness..."):
+            st.text(selected_exercise)
+            time.sleep(60)  # Give the user a minute to practice
+        st.success("Exercise complete. Remember to carry this mindfulness with you throughout your day.")
+
+def binaural_beats_page():
+    st.header("Binaural Beats Generator")
+    
+    st.write("Binaural beats are created when two slightly different frequencies are played in each ear, potentially influencing brainwave activity.")
+    
+    base_freq = st.slider("Base Frequency (Hz):", 100, 500, 200)
+    beat_freq = st.slider("Desired Beat Frequency (Hz):", 1, 40, 10)
+    duration = st.slider("Duration (seconds):", 30, 300, 60)
+    
+    if st.button("Generate Binaural Beat"):
+        with st.spinner("Generating binaural beat..."):
+            audio_data = generate_binaural_beat(base_freq, base_freq + beat_freq, duration * 1000)
+            st.audio(audio_data, format='audio/wav')
+            st.markdown(get_binary_file_downloader_html(audio_data, f"binaural_beat_{base_freq}_{beat_freq}Hz"), unsafe_allow_html=True)
+
+def affirmations_page():
+    st.header("Positive Affirmations")
+    
+    predefined_affirmations = [
+        "I am capable of achieving great things.",
+        "Every day, I'm getting stronger and more confident.",
+        "I trust in my abilities and embrace new challenges.",
+        "I radiate positivity and attract positive experiences.",
+        "I am worthy of love, respect, and success."
+    ]
+    
+    affirmation_type = st.radio("Choose affirmation type:", ["Predefined", "Custom"])
+    
+    if affirmation_type == "Predefined":
+        affirmation = st.selectbox("Select an affirmation:", predefined_affirmations)
+    else:
+        affirmation = st.text_input("Enter your custom affirmation:")
+    
+    repetitions = st.slider("Number of repetitions:", 1, 50, 10)
+    interval = st.slider("Interval between repetitions (seconds):", 1, 10, 3)
+    
+    if st.button("Start Affirmations"):
+        with st.spinner(f"Repeating affirmation {repetitions} times..."):
+            for i in range(repetitions):
+                st.write(affirmation)
+                time.sleep(interval)
+        st.success("Affirmation session complete. Carry this positive energy with you!")
+
+if __name__ == "__main__":
+    main()

pages/mind_palace.py

@@ -0,0 +1,341 @@
+import streamlit as st
+import random
+from langchain_community.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+from langchain.document_loaders import TextLoader, UnstructuredFileLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.vectorstores import FAISS
+import os
+from dotenv import load_dotenv
+import json
+from tenacity import retry, stop_after_attempt, wait_fixed
+from streamlit_chat import message
+from gtts import gTTS
+import io
+from PyPDF2 import PdfReader
+import docx2txt
+import logging
+import tempfile
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = "api71-api-92fc2ef9-9f3c-47e5-a019-18e257b04af2"
+
+# Initialize the models
+chat = ChatOpenAI(
+    model="tiiuae/falcon-180B-chat",
+    api_key=AI71_API_KEY,
+    base_url=AI71_BASE_URL,
+    streaming=True,
+)
+
+# Use SentenceTransformers for embeddings
+embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+
+def process_document(file):
+    content = ""
+    file_extension = file.name.split('.')[-1].lower()
+
+    if file_extension == 'txt':
+        content = file.getvalue().decode('utf-8')
+    elif file_extension == 'pdf':
+        try:
+            pdf_reader = PdfReader(io.BytesIO(file.getvalue()))
+            for page in pdf_reader.pages:
+                content += page.extract_text()
+        except Exception as e:
+            st.error(f"Error processing PDF: {str(e)}")
+            return None
+    elif file_extension == 'docx':
+        content = docx2txt.process(io.BytesIO(file.getvalue()))
+    else:
+        st.error(f"Unsupported file type: {file_extension}")
+        return None
+
+    if not content.strip():
+        st.warning("The uploaded file appears to be empty or unreadable. Please check the file and try again.")
+        return None
+
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    chunks = text_splitter.split_text(content)
+    
+    if not chunks:
+        st.warning("Unable to extract meaningful content from the file. Please try a different file.")
+        return None
+
+    vectorstore = FAISS.from_texts(chunks, embeddings)
+    
+    return vectorstore, content
+
+@retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
+def generate_mind_palace(topic, learning_style, user_preferences, content=None):
+    system_message = f"""
+    You are an expert in creating memorable and personalized mind palaces to aid in learning and retention. 
+    The user wants to learn about '{topic}' and their preferred learning style is '{learning_style}'.
+    Their personal preferences are: {user_preferences}
+    Create a vivid and easy-to-remember mind palace description that incorporates the topic, caters to the user's learning style, and aligns with their preferences.
+    The mind palace should have 5-7 interconnected rooms or areas, each representing a key aspect of the topic.
+    For each room, provide:
+    1. A catchy and memorable name related to the topic
+    2. A vivid description that incorporates the user's preferences and makes use of multiple senses
+    3. 3-5 key elements or objects in the room that represent important information
+    4. How these elements relate to the topic
+    5. A simple and effective memory technique or association specific to the user's learning style
+    
+    Ensure that the mind palace is coherent, with a logical flow between rooms. Use vivid imagery, familiar concepts, and emotional connections to make it more memorable.
+    
+    Format your response as a JSON object with the following structure:
+    {{
+        "palace_name": "Catchy Name of the Mind Palace",
+        "rooms": [
+            {{
+                "name": "Memorable Room Name",
+                "description": "Vivid description of the room",
+                "elements": [
+                    {{
+                        "name": "Striking Element Name",
+                        "description": "How this element relates to the topic",
+                        "memory_technique": "A simple and effective memory technique or association"
+                    }}
+                ]
+            }}
+        ]
+    }}
+    
+    Ensure that your response is a valid JSON object. Do not include any text before or after the JSON object.
+    """
+    
+    messages = [
+        SystemMessage(content=system_message),
+        HumanMessage(content=f"Create a memorable mind palace for the topic: {topic}")
+    ]
+    
+    if content:
+        messages.append(HumanMessage(content=f"Use this additional context to enhance the mind palace, focusing on the most important and memorable aspects: {content[:2000]}"))
+    
+    try:
+        response = chat.invoke(messages)
+        json_response = json.loads(response.content)
+        return json_response
+    except json.JSONDecodeError as e:
+        st.error(f"Error decoding JSON response: {str(e)}")
+        st.error("Raw response content:")
+        st.error(response.content)
+        raise
+
+def generate_audio_description(mind_palace_data):
+    description = f"Welcome to your personalized and memorable mind palace: {mind_palace_data['palace_name']}. Let's take a journey through your palace, using vivid imagery and your preferred learning style to make it unforgettable. "
+    for room in mind_palace_data['rooms']:
+        description += f"We're entering the {room['name']}. {room['description']} "
+        for element in room['elements']:
+            description += f"Focus on the {element['name']}. {element['description']} To remember this, use this simple technique: {element['memory_technique']} Take a moment to really visualize and feel this connection. "
+        description += "Now, let's move to the next room, carrying these vivid images with us. "
+    description += "We've completed our tour of your mind palace. Take a deep breath and recall the journey we've just taken, visualizing each room and its striking elements."
+
+    tts = gTTS(text=description, lang='en', slow=False)
+    fp = io.BytesIO()
+    tts.write_to_fp(fp)
+    fp.seek(0)
+    
+    return fp
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. Memorable Mind Palace Generator", layout="wide")
+    
+    # Custom CSS for dark theme
+    st.markdown("""
+    <style>
+    .main {
+        background-color: #1E1E1E;
+        color: #FFFFFF;
+    }
+    .stButton>button {
+        background-color: #4CAF50;
+        color: white;
+        font-weight: bold;
+    }
+    .stTextInput>div>div>input, .stTextArea textarea {
+        background-color: #2E2E2E;
+        color: #FFFFFF;
+    }
+    .room-expander {
+        background-color: #2E2E2E;
+        border-radius: 5px;
+        padding: 10px;
+        margin-bottom: 10px;
+    }
+    .stSelectbox>div>div>select {
+        background-color: #2E2E2E;
+        color: #FFFFFF;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+    # Sidebar
+    with st.sidebar:
+        st.title("S.H.E.R.L.O.C.K.")
+        st.subheader("Memorable Mind Palace Generator")
+        
+        st.markdown("---")
+        st.markdown("How to use your Memorable Mind Palace:")
+        st.markdown("""
+        1. Choose to enter a topic or upload a document.
+        2. Select your learning style and enter your preferences.
+        3. Generate your personalized, easy-to-remember mind palace.
+        4. Listen to the vivid audio description and imagine each room.
+        5. Explore the detailed text description, focusing on the striking elements.
+        6. Use the chat to reinforce your understanding of the mind palace.
+        7. Practice recalling information by mentally walking through your palace, using the memory techniques provided.
+        """)
+        
+        st.markdown("---")
+        st.markdown("Powered by Falcon-180B and SentenceTransformers")
+
+    # Main content
+    st.title("S.H.E.R.L.O.C.K. Memorable Mind Palace Generator")
+    
+    st.write("""
+    Welcome to the Memorable Mind Palace Generator! This tool will help you create a vivid and easy-to-remember
+    mind palace to enhance your learning and memory retention. Choose to enter a topic or upload a document,
+    select your preferred learning style, and enter your personal preferences. We'll generate a unique,
+    unforgettable mind palace tailored just for you.
+    """)
+    
+    input_method = st.radio("Choose your input method:", ["Enter a topic", "Upload a document"])
+    
+    if input_method == "Enter a topic":
+        topic = st.text_input("Enter the topic you want to learn:")
+        uploaded_file = None
+    else:
+        topic = None
+        uploaded_file = st.file_uploader("Upload a document to memorize", type=['txt', 'md', 'pdf', 'docx'])
+    
+    learning_style = st.selectbox("Choose your preferred learning style:", 
+                                  ["Visual", "Auditory", "Kinesthetic", "Reading/Writing"])
+    
+    st.write("""
+    Learning Styles:
+    - Visual: You learn best through images, diagrams, and spatial understanding. We'll create vivid mental pictures.
+    - Auditory: You prefer learning through listening and speaking. We'll focus on memorable sounds and verbal associations.
+    - Kinesthetic: You learn by doing, moving, and touching. We'll incorporate imaginary physical sensations and movements.
+    - Reading/Writing: You learn best through words. We'll use powerful written descriptions and word associations.
+    """)
+    
+    user_preferences = st.text_area("Enter your personal preferences (e.g., favorite places, hobbies, movies, or anything that resonates with you):")
+    
+    if st.button("Generate Memorable Mind Palace"):
+        with st.spinner("Crafting your unforgettable mind palace..."):
+            content = None
+            if uploaded_file is not None:
+                vectorstore, content = process_document(uploaded_file)
+                if vectorstore is None:
+                    st.error("Failed to process the uploaded document. Please try again with a different file.")
+                    return
+                topic = "Document Content"
+            elif topic is None or topic.strip() == "":
+                st.error("Please enter a topic or upload a document.")
+                return
+            
+            try:
+                mind_palace_data = generate_mind_palace(topic, learning_style, user_preferences, content)
+                if mind_palace_data is None:
+                    st.error("Failed to generate the mind palace. Please try again.")
+                    return
+                
+                st.session_state.mind_palace = mind_palace_data
+                st.session_state.chat_history = []
+                
+                # Generate audio description with selected voice
+                with st.spinner("Creating a vivid audio guide for your mind palace..."):
+                    audio_fp = generate_audio_description(mind_palace_data)
+                    st.session_state.mind_palace_audio = audio_fp
+            except Exception as e:
+                logger.error(f"An error occurred while generating the mind palace: {str(e)}")
+                st.error(f"An error occurred while generating the mind palace. Please try again.")
+                return
+
+    if 'mind_palace' in st.session_state:
+        mind_palace_data = st.session_state.mind_palace
+        
+        st.subheader(f"Your Memorable Mind Palace: {mind_palace_data['palace_name']}")
+        
+        # Audio player
+        if 'mind_palace_audio' in st.session_state:
+            try:
+                st.audio(st.session_state.mind_palace_audio, format='audio/wav')
+                st.write("👆 Listen to the vivid audio guide and imagine your mind palace. Close your eyes and immerse yourself in this mental journey.")
+            except Exception as e:
+                logger.error(f"Error playing audio: {str(e)}")
+                st.warning("There was an issue playing the audio. You can still explore the text description of your mind palace.")
+        
+        # Text description
+        for room in mind_palace_data['rooms']:
+            with st.expander(f"Room: {room['name']}", expanded=True):
+                st.markdown(f"**Description:** {room['description']}")
+                st.markdown("**Key Elements:**")
+                for element in room['elements']:
+                    st.markdown(f"- **{element['name']}:** {element['description']}")
+                    st.markdown(f"  *Memory Technique:* {element['memory_technique']}")
+        
+        st.success("Your memorable mind palace has been generated successfully! Take some time to walk through it mentally, focusing on the vivid details and connections.")
+        
+        # Chat interface
+        st.subheader("Reinforce Your Mind Palace")
+        
+        # Initialize input key if not present
+        if 'input_key' not in st.session_state:
+            st.session_state.input_key = 0
+        
+        # Display chat history
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = []
+        
+        for i, (sender, message_text) in enumerate(st.session_state.chat_history):
+            if sender == "user":
+                message(message_text, is_user=True, key=f"{i}_user")
+            else:
+                message(message_text, key=f"{i}_assistant")
+        
+        # User input text box with dynamic key
+        user_input = st.text_input("Ask a question or request a memory reinforcement exercise:", key=f"user_input_{st.session_state.input_key}")
+        
+        # Ask button below the text input
+        ask_button = st.button("Ask")
+        
+        if ask_button and user_input:
+            with st.spinner("Generating response to enhance your memory..."):
+                # Prepare context for the AI
+                context = f"Mind Palace Data: {json.dumps(mind_palace_data)}\n\n"
+                if 'uploaded_content' in st.session_state:
+                    context += f"Uploaded Document Content: {st.session_state.uploaded_content}\n\n"
+                
+                system_message = f"""
+                You are an AI assistant helping the user understand and remember their personalized mind palace.
+                Use the following context to provide responses that reinforce the vivid imagery and memory techniques used in the mind palace.
+                If asked about specific content from the uploaded document, refer to it in your response.
+                
+                {context}
+                """
+                
+                response = chat.invoke([
+                    SystemMessage(content=system_message),
+                    HumanMessage(content=user_input)
+                ])
+                
+                st.session_state.chat_history.append(("user", user_input))
+                st.session_state.chat_history.append(("assistant", response.content))
+            
+            # Increment the input key to reset the input field
+            st.session_state.input_key += 1
+            
+            # Force a rerun to update the chat history display and reset the input
+            st.experimental_rerun()
+
+if __name__ == "__main__":
+    main()

pages/mnemonics_generation.py

@@ -0,0 +1,265 @@
+import streamlit as st
+import random
+from langchain_community.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+from langchain_community.document_loaders import PyPDFLoader, TextLoader, UnstructuredMarkdownLoader, UnstructuredWordDocumentLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+import os
+from dotenv import load_dotenv
+import tempfile
+from PIL import Image
+import io
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = "api71-api-92fc2ef9-9f3c-47e5-a019-18e257b04af2"
+
+# Initialize the Falcon model
+chat = ChatOpenAI(
+    model="tiiuae/falcon-180B-chat",
+    api_key=AI71_API_KEY,
+    base_url=AI71_BASE_URL,
+    streaming=True,
+)
+
+# Initialize embeddings
+embeddings = HuggingFaceEmbeddings()
+
+def process_documents(uploaded_files):
+    documents = []
+    for uploaded_file in uploaded_files:
+        file_extension = os.path.splitext(uploaded_file.name)[1].lower()
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
+            temp_file.write(uploaded_file.getvalue())
+            temp_file_path = temp_file.name
+
+        if file_extension == '.pdf':
+            loader = PyPDFLoader(temp_file_path)
+        elif file_extension == '.txt':
+            loader = TextLoader(temp_file_path)
+        elif file_extension == '.md':
+            loader = UnstructuredMarkdownLoader(temp_file_path)
+        elif file_extension in ['.doc', '.docx']:
+            loader = UnstructuredWordDocumentLoader(temp_file_path)
+        else:
+            st.warning(f"Unsupported file type: {file_extension}")
+            continue
+
+        documents.extend(loader.load())
+        os.unlink(temp_file_path)
+
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    texts = text_splitter.split_documents(documents)
+    
+    vectorstore = FAISS.from_documents(texts, embeddings)
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+    
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=chat,
+        chain_type="stuff",
+        retriever=retriever,
+        return_source_documents=True
+    )
+    
+    return qa_chain
+
+def generate_mnemonic(topic, user_preferences):
+    prompt = f"""
+    Generate a memorable mnemonic for the topic: {topic}.
+    Consider the user's preferences: {user_preferences}.
+    The mnemonic should be easy to remember and relate to the topic.
+    Also provide a brief explanation of how the mnemonic relates to the topic.
+    """
+    response = chat.invoke([HumanMessage(content=prompt)])
+    return response.content
+
+def generate_quiz_question(mnemonic):
+    quiz_prompt = f"""
+    Create a quiz question based on the mnemonic: {mnemonic}
+    Format your response as follows:
+    Question: [Your question here]
+    Answer: [Your answer here]
+    """
+    quiz_response = chat.invoke([HumanMessage(content=quiz_prompt)])
+    content = quiz_response.content.strip()
+    
+    try:
+        question_part, answer_part = content.split("Answer:", 1)
+        question = question_part.replace("Question:", "").strip()
+        answer = answer_part.strip()
+    except ValueError:
+        question = content
+        answer = "Unable to generate a specific answer. Please refer to the mnemonic."
+    
+    return question, answer
+
+def generate_image_prompt(mnemonic):
+    prompt = f"""
+    Create a detailed image prompt for Midjourney based on the mnemonic: {mnemonic}
+    The image should visually represent the key elements of the mnemonic.
+    """
+    response = chat.invoke([HumanMessage(content=prompt)])
+    return response.content
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. Mnemonic Generator", page_icon="🧠", layout="wide")
+
+    # Custom CSS
+    st.markdown("""
+    <style>
+    .stApp {
+        background-color: #f0f2f6;
+    }
+    .main .block-container {
+        padding-top: 2rem;
+    }
+    .stButton>button {
+        background-color: #4CAF50;
+        color: white;
+        font-weight: bold;
+    }
+    .stTextInput>div>div>input {
+        background-color: #ffffff;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+    st.title("🧠 S.H.E.R.L.O.C.K. Mnemonic Generator")
+
+    # Initialize session state
+    if 'generated_mnemonic' not in st.session_state:
+        st.session_state.generated_mnemonic = None
+    if 'quiz_question' not in st.session_state:
+        st.session_state.quiz_question = None
+    if 'quiz_answer' not in st.session_state:
+        st.session_state.quiz_answer = None
+    if 'image_prompt' not in st.session_state:
+        st.session_state.image_prompt = None
+
+    # Sidebar
+    with st.sidebar:
+        st.header("📚 Document Upload")
+        uploaded_files = st.file_uploader("Upload documents (optional)", type=["pdf", "txt", "md", "doc", "docx"], accept_multiple_files=True)
+        if uploaded_files:
+            qa_chain = process_documents(uploaded_files)
+            st.success(f"{len(uploaded_files)} document(s) processed successfully!")
+        else:
+            qa_chain = None
+
+        st.header("🎨 User Preferences")
+        user_preferences = st.text_area("Enter your interests or preferences:")
+
+    # Main area
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        st.header("🔍 Generate Mnemonic")
+        topic = st.text_input("Enter the topic for your mnemonic:")
+        
+        if st.button("Generate Mnemonic"):
+            if topic:
+                with st.spinner("Generating mnemonic..."):
+                    mnemonic = generate_mnemonic(topic, user_preferences)
+                st.session_state.generated_mnemonic = mnemonic
+                
+                with st.spinner("Generating quiz question..."):
+                    question, answer = generate_quiz_question(mnemonic)
+                st.session_state.quiz_question = question
+                st.session_state.quiz_answer = answer
+
+                with st.spinner("Generating image prompt..."):
+                    image_prompt = generate_image_prompt(mnemonic)
+                st.session_state.image_prompt = image_prompt
+            else:
+                st.warning("Please enter a topic to generate a mnemonic.")
+
+    with col2:
+        if st.session_state.generated_mnemonic:
+            st.header("📝 Generated Mnemonic")
+            st.write(st.session_state.generated_mnemonic)
+
+    # Quiz section
+    if st.session_state.quiz_question:
+        st.header("🧠 Mnemonic Quiz")
+        st.write(st.session_state.quiz_question)
+        user_answer = st.text_input("Your answer:")
+        if st.button("Submit Answer"):
+            if user_answer.lower() == st.session_state.quiz_answer.lower():
+                st.success("🎉 Correct! Well done.")
+            else:
+                st.error(f"❌ Not quite. The correct answer is: {st.session_state.quiz_answer}")
+
+    # Image prompt section
+    if st.session_state.image_prompt:
+        st.header("🖼️ Image Prompt")
+        st.write(st.session_state.image_prompt)
+        st.info("You can use this prompt with Midjourney or other image generation tools to create a visual representation of your mnemonic.")
+
+    # Document Q&A section
+    if qa_chain:
+        st.header("📚 Document Q&A")
+        user_question = st.text_input("Ask a question about the uploaded document(s):")
+        if st.button("Get Answer"):
+            with st.spinner("Searching for the answer..."):
+                result = qa_chain({"query": user_question})
+                st.subheader("Answer:")
+                st.write(result["result"])
+                st.subheader("Sources:")
+                for source in result["source_documents"]:
+                    st.write(source.page_content)
+
+    # Mnemonic visualization
+    if st.session_state.generated_mnemonic:
+        st.header("🎨 Mnemonic Visualization")
+        visualization_type = st.selectbox("Choose visualization type:", ["Word Cloud", "Mind Map"])
+        if st.button("Generate Visualization"):
+            with st.spinner("Generating visualization..."):
+                visualization_prompt = f"""
+                Create a detailed description of a {visualization_type} based on the mnemonic:
+                {st.session_state.generated_mnemonic}
+                Describe the layout, key elements, and their relationships.
+                """
+                visualization_description = chat.invoke([HumanMessage(content=visualization_prompt)]).content
+                st.write(visualization_description)
+                st.info("You can use this description to create a visual representation of your mnemonic using tools like Canva or Mindmeister.")
+
+    # Export options
+    if st.session_state.generated_mnemonic:
+        st.header("📤 Export Options")
+        export_format = st.selectbox("Choose export format:", ["Text", "PDF", "Markdown"])
+        if st.button("Export Mnemonic"):
+            export_content = f"""
+            Topic: {topic}
+            
+            Mnemonic:
+            {st.session_state.generated_mnemonic}
+            
+            Quiz Question:
+            {st.session_state.quiz_question}
+            
+            Quiz Answer:
+            {st.session_state.quiz_answer}
+            
+            Image Prompt:
+            {st.session_state.image_prompt}
+            """
+            
+            if export_format == "Text":
+                st.download_button("Download Text", export_content, file_name="mnemonic_export.txt")
+            elif export_format == "PDF":
+                # You'd need to implement PDF generation here, for example using reportlab
+                st.warning("PDF export not implemented in this example.")
+            elif export_format == "Markdown":
+                st.download_button("Download Markdown", export_content, file_name="mnemonic_export.md")
+
+    # Footer
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("Powered by Falcon-180B and Streamlit")
+
+if __name__ == "__main__":
+    main()

pages/notes_generation.py

@@ -0,0 +1,213 @@
+import streamlit as st
+import os
+from dotenv import load_dotenv
+from langchain_community.chat_models import ChatOpenAI
+from langchain_community.document_loaders import PyPDFLoader, TextLoader, UnstructuredMarkdownLoader, Docx2txtLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+from langchain.prompts import PromptTemplate
+import tempfile
+from typing import List, Dict
+import json
+from datetime import datetime
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = "api71-api-92fc2ef9-9f3c-47e5-a019-18e257b04af2"
+
+# Initialize the Falcon model
+@st.cache_resource
+def get_llm():
+    return ChatOpenAI(
+        model="tiiuae/falcon-180B-chat",
+        api_key=AI71_API_KEY,
+        base_url=AI71_BASE_URL,
+        streaming=True,
+    )
+
+# Initialize embeddings
+@st.cache_resource
+def get_embeddings():
+    return HuggingFaceEmbeddings()
+
+def process_document(file_content, file_type):
+    with tempfile.NamedTemporaryFile(delete=False, suffix=f'.{file_type}') as tmp_file:
+        if isinstance(file_content, str):
+            tmp_file.write(file_content.encode('utf-8'))
+        else:
+            tmp_file.write(file_content)
+        tmp_file_path = tmp_file.name
+
+    if file_type == 'pdf':
+        loader = PyPDFLoader(tmp_file_path)
+    elif file_type == 'txt':
+        loader = TextLoader(tmp_file_path)
+    elif file_type == 'md':
+        loader = UnstructuredMarkdownLoader(tmp_file_path)
+    elif file_type == 'docx':
+        loader = Docx2txtLoader(tmp_file_path)
+    else:
+        raise ValueError(f"Unsupported file type: {file_type}")
+
+    documents = loader.load()
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    texts = text_splitter.split_documents(documents)
+    
+    vectorstore = FAISS.from_documents(texts, get_embeddings())
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+    
+    os.unlink(tmp_file_path)
+    return retriever
+
+def generate_notes(retriever, topic, style, length):
+    prompt_template = f"""
+    You are an expert note-taker and summarizer. Your task is to create {style} and {length} notes on the given topic.
+    Use the following guidelines:
+    1. Focus on key concepts and important details.
+    2. Use bullet points or numbered lists for clarity.
+    3. Include relevant examples or explanations where necessary.
+    4. Organize the information in a logical and easy-to-follow structure.
+    5. Aim for clarity without sacrificing important information.
+
+    Context: {{context}}
+    Topic: {{question}}
+    
+    Notes:
+    """
+    
+    PROMPT = PromptTemplate(
+        template=prompt_template,
+        input_variables=["context", "question"]
+    )
+    
+    chain_type_kwargs = {"prompt": PROMPT}
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=get_llm(),
+        chain_type="stuff",
+        retriever=retriever,
+        chain_type_kwargs=chain_type_kwargs
+    )
+    
+    result = qa_chain({"query": topic})
+    return result['result']
+
+def save_notes(notes: str, topic: str):
+    notes_data = load_notes_data()
+    timestamp = datetime.now().isoformat()
+    notes_data.append({"topic": topic, "notes": notes, "timestamp": timestamp})
+    with open("saved_notes.json", "w") as f:
+        json.dump(notes_data, f)
+
+def load_notes_data() -> List[Dict]:
+    try:
+        with open("saved_notes.json", "r") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return []
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. Notes Generator", layout="wide")
+
+    st.title("S.H.E.R.L.O.C.K. Notes Generator")
+
+    st.markdown("""
+    This tool helps you generate concise and relevant notes on specific topics. 
+    You can upload a document or enter text directly.
+    """)
+
+    # Sidebar content
+    st.sidebar.title("About S.H.E.R.L.O.C.K.")
+    st.sidebar.markdown("""
+    S.H.E.R.L.O.C.K. (Summarizing Helper & Effective Research Liaison for Organizing Comprehensive Knowledge) 
+    is an advanced AI-powered tool designed to assist you in generating comprehensive notes from various sources.
+
+    Key Features:
+    - Multi-format support (PDF, TXT, MD, DOCX)
+    - Customizable note generation
+    - Intelligent text processing
+    - Save and retrieve notes
+
+    How to use:
+    1. Choose your input method
+    2. Process your document or text
+    3. Enter a topic and customize note style
+    4. Generate and save your notes
+
+    Enjoy your enhanced note-taking experience!
+    """)
+
+    input_method = st.radio("Choose input method:", ("Upload Document", "Enter Text"))
+
+    if input_method == "Upload Document":
+        uploaded_file = st.file_uploader("Upload a document", type=["pdf", "txt", "md", "docx"])
+        if uploaded_file:
+            file_type = uploaded_file.name.split('.')[-1].lower()
+            file_content = uploaded_file.read()
+            st.success("Document uploaded successfully!")
+            
+            with st.spinner("Processing document..."):
+                retriever = process_document(file_content, file_type)
+                st.session_state.retriever = retriever
+            st.success("Document processed!")
+    elif input_method == "Enter Text":
+        text_input = st.text_area("Enter your text here:", height=200)
+        if text_input:
+            with st.spinner("Processing text..."):
+                retriever = process_document(text_input, 'txt')
+                st.session_state.retriever = retriever
+            st.success("Text processed!")
+
+    topic = st.text_input("Enter the topic for note generation:")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        style = st.selectbox("Note Style", ["Concise", "Detailed", "Academic", "Casual"])
+    with col2:
+        length = st.selectbox("Note Length", ["Short", "Medium", "Long"])
+
+    if st.button("Generate Notes"):
+        if topic and hasattr(st.session_state, 'retriever'):
+            with st.spinner("Generating notes..."):
+                try:
+                    notes = generate_notes(st.session_state.retriever, topic, style, length)
+                    st.subheader("Generated Notes:")
+                    st.markdown(notes)
+                    
+                    # Download button for the generated notes
+                    st.download_button(
+                        label="Download Notes",
+                        data=notes,
+                        file_name=f"{topic.replace(' ', '_')}_notes.txt",
+                        mime="text/plain"
+                    )
+
+                    # Save notes
+                    if st.button("Save Notes"):
+                        save_notes(notes, topic)
+                        st.success("Notes saved successfully!")
+                except Exception as e:
+                    st.error(f"An error occurred while generating notes: {str(e)}")
+        else:
+            st.warning("Please upload a document or enter text, and specify a topic before generating notes.")
+
+    # Display saved notes
+    st.sidebar.subheader("Saved Notes")
+    saved_notes = load_notes_data()
+    for i, note in enumerate(saved_notes):
+        if st.sidebar.button(f"{note['topic']} - {note['timestamp'][:10]}", key=f"saved_note_{i}"):
+            st.subheader(f"Saved Notes: {note['topic']}")
+            st.markdown(note['notes'])
+
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("Powered by Falcon-180B and Streamlit")
+
+    # Add a footer
+    st.markdown("---")
+    st.markdown("Created by Your Team Name | © 2024")
+
+if __name__ == "__main__":
+    main()

pages/sherlock_observation.py

@@ -0,0 +1,191 @@
+import streamlit as st
+import random
+from langchain_community.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+from langchain_community.document_loaders import PyPDFLoader, TextLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+import os
+from dotenv import load_dotenv
+import tempfile
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = "api71-api-92fc2ef9-9f3c-47e5-a019-18e257b04af2"
+
+# Initialize the Falcon model
+chat = ChatOpenAI(
+    model="tiiuae/falcon-180B-chat",
+    api_key=AI71_API_KEY,
+    base_url=AI71_BASE_URL,
+    streaming=True,
+)
+
+# Initialize embeddings
+embeddings = HuggingFaceEmbeddings()
+
+# Expanded list of predefined topics
+PREDEFINED_TOPICS = [
+    "Quantum Computing", "Artificial Intelligence Ethics", "Blockchain Technology",
+    "Neuroscience", "Climate Change Mitigation", "Space Exploration",
+    "Renewable Energy", "Genetic Engineering", "Cybersecurity",
+    "Machine Learning", "Nanotechnology", "Robotics",
+    "Virtual Reality", "Augmented Reality", "Internet of Things",
+    "5G Technology", "Autonomous Vehicles", "Bioinformatics",
+    "Cloud Computing", "Data Science", "Artificial General Intelligence",
+    "Quantum Cryptography", "3D Printing", "Smart Cities",
+    "Biotechnology", "Fusion Energy", "Sustainable Agriculture",
+    "Space Tourism", "Quantum Sensors", "Brain-Computer Interfaces",
+    "Personalized Medicine", "Synthetic Biology", "Exoplanets",
+    "Dark Matter", "CRISPR Technology", "Quantum Internet",
+    "Deep Learning", "Edge Computing", "Humanoid Robots",
+    "Drone Technology", "Quantum Supremacy", "Neuromorphic Computing",
+    "Asteroid Mining", "Bionic Implants", "Smart Materials",
+    "Quantum Dots", "Lab-grown Meat", "Vertical Farming",
+    "Hyperloop Transportation", "Molecular Nanotechnology", "Quantum Metrology",
+    "Artificial Photosynthesis", "Cognitive Computing", "Swarm Robotics",
+    "Metamaterials", "Neuroplasticity", "Quantum Machine Learning",
+    "Green Hydrogen", "Organ-on-a-Chip", "Bioprinting",
+    "Plasma Physics", "Quantum Simulation", "Soft Robotics",
+    "Geoengineering", "Exoskeletons", "Programmable Matter",
+    "Graphene Applications", "Quantum Sensing", "Neuralink",
+    "Holographic Displays", "Quantum Error Correction", "Synthetic Genomes",
+    "Carbon Capture and Storage", "Quantum Memory", "Organoids",
+    "Artificial Synapses", "Quantum Imaging", "Biosensors",
+    "Memristors", "Quantum Annealing", "DNA Data Storage",
+    "Cultured Meat", "Quantum Radar", "Neuromorphic Hardware",
+    "Quantum Entanglement", "Phytomining", "Biohacking",
+    "Topological Quantum Computing", "Neuroprosthetics", "Optogenetics",
+    "Quantum Gravity", "Molecular Machines", "Biomimicry",
+    "Quantum Teleportation", "Neurogenesis", "Bioelectronics",
+    "Quantum Tunneling", "Tissue Engineering", "Bioremediation",
+    "Quantum Photonics", "Synthetic Neurobiology", "Nanomedicine",
+    "Quantum Biology", "Biogeochemistry", "Molecular Gastronomy",
+    "Quantum Thermodynamics", "Nutrigenomics", "Biomechatronics",
+    "Quantum Chemistry", "Psychoneuroimmunology", "Nanophotonics",
+    "Quantum Optics", "Neuroeconomics", "Bionanotechnology"
+]
+
+def process_document(file):
+    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.name)[1]) as temp_file:
+        temp_file.write(file.getvalue())
+        temp_file_path = temp_file.name
+
+    if file.name.endswith('.pdf'):
+        loader = PyPDFLoader(temp_file_path)
+    else:
+        loader = TextLoader(temp_file_path)
+
+    documents = loader.load()
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    texts = text_splitter.split_documents(documents)
+    
+    vectorstore = FAISS.from_documents(texts, embeddings)
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+    
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=chat,
+        chain_type="stuff",
+        retriever=retriever,
+        return_source_documents=True
+    )
+    
+    os.unlink(temp_file_path)
+    return qa_chain
+
+def get_sherlock_analysis(topic, qa_chain=None):
+    system_prompt = """
+    You are Sherlock Holmes, the world's greatest detective and master of observation and deduction. 
+    Your task is to provide an in-depth analysis of the given topic, offering unique insights on how to approach learning it from the ground up. 
+    Your analysis should:
+    1. Break down the topic into its fundamental components.
+    2. Identify key concepts and their relationships.
+    3. Suggest a structured approach to learning, starting from first principles.
+    4. Highlight potential challenges and how to overcome them.
+    5. Provide a unique point of view that encourages critical thinking.
+    Your response should be detailed, insightful, and encourage a deep understanding of the subject.
+    """
+
+    if qa_chain:
+        result = qa_chain({"query": f"Provide a Sherlock Holmes style analysis of the topic: {topic}"})
+        response = result['result']
+    else:
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=f"Analyze the following topic: {topic}")
+        ]
+        response = chat.invoke(messages).content
+    
+    return response
+
+def chunk_text(text, max_chunk_size=4000):
+    chunks = []
+    current_chunk = ""
+    for sentence in text.split(". "):
+        if len(current_chunk) + len(sentence) < max_chunk_size:
+            current_chunk += sentence + ". "
+        else:
+            chunks.append(current_chunk)
+            current_chunk = sentence + ". "
+    if current_chunk:
+        chunks.append(current_chunk)
+    return chunks
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. Observation", page_icon="🔍", layout="wide")
+
+    st.title("🕵️ S.H.E.R.L.O.C.K. Observation")
+    st.markdown("*Uncover the depths of any subject with the keen insight of Sherlock Holmes*")
+
+    col1, col2 = st.columns([2, 1])
+
+    with col2:
+        st.subheader("Choose Your Method")
+        method = st.radio("Select input method:", ["Enter Topic", "Upload Document", "Choose from List"])
+
+        if method == "Enter Topic":
+            topic = st.text_input("Enter your topic of interest:")
+        elif method == "Upload Document":
+            uploaded_file = st.file_uploader("Upload a document (PDF or TXT)", type=["pdf", "txt"])
+            if uploaded_file:
+                topic = uploaded_file.name
+        else:
+            topic = st.selectbox("Choose a topic:", PREDEFINED_TOPICS)
+
+        if st.button("Analyze", key="analyze_button"):
+            if method == "Upload Document" and uploaded_file:
+                qa_chain = process_document(uploaded_file)
+                analysis = get_sherlock_analysis(topic, qa_chain)
+            elif topic:
+                analysis = get_sherlock_analysis(topic)
+            else:
+                st.warning("Please provide a topic or upload a document.")
+                return
+
+            col1.markdown("## Sherlock's Analysis")
+            chunks = chunk_text(analysis)
+            for chunk in chunks:
+                col1.markdown(chunk)
+
+    st.sidebar.image("https://upload.wikimedia.org/wikipedia/commons/c/cd/Sherlock_Holmes_Portrait_Paget.jpg", use_column_width=True)
+    st.sidebar.title("About S.H.E.R.L.O.C.K. Observation")
+    st.sidebar.markdown("""
+    S.H.E.R.L.O.C.K. Observation is your personal detective for any subject. 
+    It provides:
+    - In-depth analysis of topics
+    - Unique perspectives on learning approaches
+    - First principles breakdown of subjects
+    - Critical thinking encouragement
+    
+    Let Sherlock guide you through the intricacies of any field of study!
+    """)
+
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("Powered by Falcon-180B and Streamlit")
+
+if __name__ == "__main__":
+    main()

pages/study_roadmap.py

@@ -0,0 +1,481 @@
+import streamlit as st
+import networkx as nx
+import plotly.graph_objects as go
+from dotenv import load_dotenv
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional
+import json
+import pandas as pd
+import time
+from datetime import datetime
+import random
+import re
+from PIL import Image
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = "api71-api-92fc2ef9-9f3c-47e5-a019-18e257b04af2"
+
+# Initialize the Falcon model
+chat = ChatOpenAI(
+    model="tiiuae/falcon-180B-chat",
+    api_key=AI71_API_KEY,
+    base_url=AI71_BASE_URL,
+    temperature=0.7,
+)
+
+class RoadmapStep(BaseModel):
+    title: str
+    description: str
+    resources: List[Dict[str, str]] = Field(default_factory=list)
+    estimated_time: str
+    how_to_use: Optional[str] = None
+
+class Roadmap(BaseModel):
+    steps: Dict[str, RoadmapStep] = Field(default_factory=dict)
+
+def clean_json(content):
+    # Remove any leading or trailing whitespace
+    content = content.strip()
+    
+    # Ensure the content starts and ends with curly braces
+    if not content.startswith('{'):
+        content = '{' + content
+    if not content.endswith('}'):
+        content = content + '}'
+    
+    # Remove any newline characters and extra spaces
+    content = ' '.join(content.split())
+    
+    # Escape any unescaped double quotes within string values
+    content = re.sub(r'(?<!\\)"(?=(?:(?:[^"]*"){2})*[^"]*$)', r'\"', content)
+    
+    return content
+
+def ensure_valid_json(content):
+    # First, apply our existing cleaning function
+    content = clean_json(content)
+    
+    # Use regex to find and fix unquoted property names
+    pattern = r'(\{|\,)\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:'
+    content = re.sub(pattern, r'\1 "\2":', content)
+    
+    # Replace single quotes with double quotes
+    content = content.replace("'", '"')
+    
+    # Attempt to parse the JSON to catch any remaining issues
+    try:
+        json_obj = json.loads(content)
+        return json.dumps(json_obj)  # Return a properly formatted JSON string
+    except json.JSONDecodeError as e:
+        # If we still can't parse it, log the error and return None
+        logger.error(f"Failed to parse JSON after cleaning: {str(e)}")
+        logger.debug(f"Problematic JSON: {content}")
+        return None
+
+def generate_roadmap(topic):
+    levels = [
+        "knowledge",
+        "comprehension",
+        "application",
+        "analysis",
+        "synthesis",
+        "evaluation"
+    ]
+
+    roadmap = Roadmap()
+
+    for level in levels:
+        try:
+            logger.info(f"Generating roadmap step for topic: {topic} at {level} level")
+            step = generate_simplified_step(topic, level, chat)
+            roadmap.steps[level] = step
+            logger.info(f"Added step for {level} level")
+            
+        except Exception as e:
+            logger.error(f"Error in generate_roadmap for {level}: {str(e)}")
+            step = create_fallback_step(topic, level, chat)
+            roadmap.steps[level] = step
+
+    logger.info("Roadmap generation complete")
+    return roadmap
+
+def generate_diverse_resources(topic, level):
+    encoded_topic = topic.replace(' ', '+')
+    encoded_level = level.replace(' ', '+')
+    
+    resource_templates = [
+        {"title": "Wikipedia", "url": f"https://en.wikipedia.org/wiki/{topic.replace(' ', '_')}"},
+        {"title": "YouTube Overview", "url": f"https://www.youtube.com/results?search_query={encoded_topic}+{encoded_level}"},
+        {"title": "Coursera Courses", "url": f"https://www.coursera.org/search?query={encoded_topic}"},
+        {"title": "edX Courses", "url": f"https://www.edx.org/search?q={encoded_topic}"},
+        {"title": "Brilliant", "url": f"https://brilliant.org/search/?q={encoded_topic}"},
+        {"title": "Google Scholar", "url": f"https://scholar.google.com/scholar?q={encoded_topic}"},
+        {"title": "MIT OpenCourseWare", "url": f"https://ocw.mit.edu/search/?q={encoded_topic}"},
+        {"title": "Khan Academy", "url": f"https://www.khanacademy.org/search?query={encoded_topic}"},
+        {"title": "TED Talks", "url": f"https://www.ted.com/search?q={encoded_topic}"},
+        {"title": "arXiv Papers", "url": f"https://arxiv.org/search/?query={encoded_topic}&searchtype=all"},
+        {"title": "ResearchGate", "url": f"https://www.researchgate.net/search/publication?q={encoded_topic}"},
+        {"title": "Academic Earth", "url": f"https://academicearth.org/search/?q={encoded_topic}"},
+    ]
+    
+    # Randomly select 5-7 resources
+    num_resources = random.randint(5, 7)
+    selected_resources = random.sample(resource_templates, num_resources)
+    
+    return selected_resources
+
+def create_fallback_step(topic, level, chat):
+    def generate_component(prompt, default_value):
+        try:
+            response = chat.invoke([{"role": "system", "content": prompt}])
+            return response.content.strip() or default_value
+        except Exception as e:
+            logger.error(f"Error generating component: {str(e)}")
+            return default_value
+
+    # Generate title
+    title_prompt = f"Create a concise title (max 10 words) for a study step about {topic} at the {level} level of Bloom's Taxonomy."
+    default_title = f"{level.capitalize()} Step for {topic}"
+    title = generate_component(title_prompt, default_title)
+
+    # Generate description
+    description_prompt = f"""Write a detailed description (500-700 words) for a study step about {topic} at the {level} level of Bloom's Taxonomy. 
+    Explain what this step entails, how the user should approach it, and why it's important for mastering the topic at this level. 
+    The description should be specific to {topic} and not a generic explanation of the Bloom's Taxonomy level."""
+    default_description = f"In this step, you will focus on {topic} at the {level} level. This involves understanding key concepts and theories related to {topic}. Engage with the provided resources to build a strong foundation."
+    description = generate_component(description_prompt, default_description)
+
+    # Generate estimated time
+    time_prompt = f"Estimate the time needed to complete a study step about {topic} at the {level} level of Bloom's Taxonomy. Provide the answer in a format like '3-4 days' or '1-2 weeks'."
+    default_time = "3-4 days"
+    estimated_time = generate_component(time_prompt, default_time)
+
+    # Generate how to use
+    how_to_use_prompt = f"""Write a paragraph (100-150 words) on how to effectively use the {level} level of Bloom's Taxonomy when studying {topic}. 
+    Include tips and strategies specific to {topic} at this {level} level."""
+    default_how_to_use = f"Explore the provided resources and take notes on key concepts related to {topic}. Practice explaining these concepts in your own words to reinforce your understanding at the {level} level."
+    how_to_use = generate_component(how_to_use_prompt, default_how_to_use)
+
+    return RoadmapStep(
+        title=title,
+        description=description,
+        resources=generate_diverse_resources(topic, level),
+        estimated_time=estimated_time,
+        how_to_use=how_to_use
+    )
+
+def create_interactive_graph(roadmap):
+    G = nx.DiGraph()
+    color_map = {
+        'Knowledge': '#FF6B6B',
+        'Comprehension': '#4ECDC4',
+        'Application': '#45B7D1',
+        'Analysis': '#FFA07A',
+        'Synthesis': '#98D8C8',
+        'Evaluation': '#F9D56E'
+    }
+    
+    for i, (level, step) in enumerate(roadmap.steps.items()):
+        G.add_node(step.title, level=level.capitalize(), pos=(i, -i))
+    
+    pos = nx.get_node_attributes(G, 'pos')
+    
+    edge_trace = go.Scatter(
+        x=[], y=[],
+        line=dict(width=2, color='#888'),
+        hoverinfo='none',
+        mode='lines')
+
+    node_trace = go.Scatter(
+        x=[], y=[],
+        mode='markers+text',
+        hoverinfo='text',
+        marker=dict(
+            showscale=False,
+            color=[],
+            size=30,
+            line_width=2
+        ),
+        text=[],
+        textposition="top center"
+    )
+
+    for node in G.nodes():
+        x, y = pos[node]
+        node_trace['x'] += (x,)
+        node_trace['y'] += (y,)
+        node_info = f"{node}<br>Level: {G.nodes[node]['level']}"
+        node_trace['text'] += (node_info,)
+        node_trace['marker']['color'] += (color_map.get(G.nodes[node]['level'], '#CCCCCC'),)
+
+    fig = go.Figure(data=[edge_trace, node_trace],
+                    layout=go.Layout(
+                        title='Interactive Study Roadmap',
+                        titlefont_size=16,
+                        showlegend=False,
+                        hovermode='closest',
+                        margin=dict(b=20,l=5,r=5,t=40),
+                        annotations=[dict(
+                            text="",
+                            showarrow=False,
+                            xref="paper", yref="paper",
+                            x=0.005, y=-0.002
+                        )],
+                        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                        plot_bgcolor='rgba(0,0,0,0)',
+                        paper_bgcolor='rgba(0,0,0,0)'
+                    ))
+    
+    # Add a color legend
+    for level, color in color_map.items():
+        fig.add_trace(go.Scatter(
+            x=[None], y=[None],
+            mode='markers',
+            marker=dict(size=10, color=color),
+            showlegend=True,
+            name=level
+        ))
+    
+    fig.update_layout(legend=dict(
+        orientation="h",
+        yanchor="bottom",
+        y=1.02,
+        xanchor="right",
+        x=1
+    ))
+    
+    return fig
+
+def get_user_progress(roadmap):
+    if 'user_progress' not in st.session_state:
+        st.session_state.user_progress = {}
+    
+    for level, step in roadmap.steps.items():
+        if step.title not in st.session_state.user_progress:
+            st.session_state.user_progress[step.title] = 0
+    
+    return st.session_state.user_progress
+
+def update_user_progress(step_title, progress):
+    st.session_state.user_progress[step_title] = progress
+
+def calculate_overall_progress(progress_dict):
+    if not progress_dict:
+        return 0
+    total_steps = len(progress_dict)
+    completed_steps = sum(1 for progress in progress_dict.values() if progress == 100)
+    return (completed_steps / total_steps) * 100
+
+def generate_simplified_step(topic, level, chat):
+    prompt = f"""Create a detailed study step for the topic: {topic} at the {level} level of Bloom's Taxonomy.
+    
+    Provide:
+    1. A descriptive title (max 10 words)
+    2. A detailed description (500-700 words) explaining what this step entails, how the user should approach it, and why it's important for mastering the topic at this level. The description should be specific to {topic} and not a generic explanation of the Bloom's Taxonomy level.
+    3. Estimated time for completion (e.g., 3-4 days, 1-2 weeks, etc.)
+    4. A paragraph (100-150 words) on how to use this level effectively, including tips and strategies specific to {topic} at this {level} level
+
+    Format your response as a valid JSON object with the following structure:
+    {{
+        "title": "Step title",
+        "description": "Step description",
+        "estimated_time": "Estimated time",
+        "how_to_use": "Paragraph on how to use this level effectively"
+    }}
+    """
+    
+    try:
+        response = chat.invoke([{"role": "system", "content": prompt}])
+        valid_json = ensure_valid_json(response.content)
+        if valid_json is None:
+            raise ValueError("Failed to create valid JSON")
+        
+        step_dict = json.loads(valid_json)
+        
+        # Generate diverse resources
+        resources = generate_diverse_resources(topic, level)
+        
+        return RoadmapStep(
+            title=step_dict["title"],
+            description=step_dict["description"],
+            resources=resources,
+            estimated_time=step_dict["estimated_time"],
+            how_to_use=step_dict["how_to_use"]
+        )
+    except Exception as e:
+        logger.error(f"Error in generate_simplified_step for {level}: {str(e)}")
+        return create_fallback_step(topic, level, chat)
+
+
+
+def display_step(step, level, user_progress):
+    with st.expander(f"{level.capitalize()}: {step.title}"):
+        st.write(f"**Description:** {step.description}")
+        st.write(f"**Estimated Time:** {step.estimated_time}")
+        st.write("**Resources:**")
+        for resource in step.resources:
+            st.markdown(f"- [{resource['title']}]({resource['url']})")
+            if 'contribution' in resource:
+                st.write(f"  *{resource['contribution']}*")
+        
+        # Check if how_to_use exists before displaying it
+        if step.how_to_use:
+            st.write("**How to use this level effectively:**")
+            st.write(step.how_to_use)
+        
+        progress = st.slider(f"Progress for {step.title}", 0, 100, user_progress.get(step.title, 0), key=f"progress_{level}")
+        update_user_progress(step.title, progress)
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. Study Roadmap Generator", layout="wide")
+
+    # Custom CSS for dark theme
+    st.markdown("""
+        <style>
+        .stApp {
+            background-color: #1E1E1E;
+            color: #FFFFFF;
+        }
+        .stButton>button {
+            background-color: #4CAF50;
+            color: white;
+            border-radius: 5px;
+        }
+        .stProgress > div > div > div > div {
+            background-color: #4CAF50;
+        }
+        .streamlit-expanderHeader {
+            background-color: #2E2E2E;
+            color: #FFFFFF;
+        }
+        .streamlit-expanderContent {
+            background-color: #2E2E2E;
+            color: #FFFFFF;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    st.title("🧠 S.H.E.R.L.O.C.K. Study Roadmap Generator")
+    st.write("Generate a comprehensive study roadmap based on first principles for any topic.")
+
+    # Sidebar
+    with st.sidebar:
+        st.image("https://placekitten.com/300/200", caption="S.H.E.R.L.O.C.K.", use_column_width=True)
+        st.markdown("""
+        ## About S.H.E.R.L.O.C.K.
+        **S**tudy **H**elper for **E**fficient **R**oadmaps and **L**earning **O**ptimization using **C**omprehensive **K**nowledge
+
+        S.H.E.R.L.O.C.K. is your AI-powered study companion, designed to create personalized learning roadmaps for any topic. It breaks down complex subjects into manageable steps, ensuring a comprehensive understanding from fundamentals to advanced concepts.
+        """)
+
+        st.subheader("📋 Todo List")
+        if 'todos' not in st.session_state:
+            st.session_state.todos = []
+        
+        new_todo = st.text_input("Add a new todo:")
+        if st.button("Add Todo", key="add_todo"):
+            if new_todo:
+                st.session_state.todos.append({"task": new_todo, "completed": False})
+                st.success("Todo added successfully!")
+            else:
+                st.warning("Please enter a todo item.")
+        
+        for i, todo in enumerate(st.session_state.todos):
+            col1, col2, col3 = st.columns([0.05, 0.8, 0.15])
+            with col1:
+                todo['completed'] = st.checkbox("", todo['completed'], key=f"todo_{i}")
+            with col2:
+                st.write(todo['task'], key=f"todo_text_{i}")
+            with col3:
+                if st.button("🗑️", key=f"delete_{i}", help="Delete todo"):
+                    st.session_state.todos.pop(i)
+                    st.experimental_rerun()
+
+        st.subheader("⏱️ Pomodoro Timer")
+        pomodoro_duration = st.slider("Pomodoro Duration (minutes)", 1, 60, 25)
+        if st.button("Start Pomodoro"):
+            progress_bar = st.progress(0)
+            for i in range(pomodoro_duration * 60):
+                time.sleep(1)
+                progress_bar.progress((i + 1) / (pomodoro_duration * 60))
+            st.success("Pomodoro completed!")
+            if 'achievements' not in st.session_state:
+                st.session_state.achievements = set()
+            st.session_state.achievements.add("Consistent Learner")
+
+    topic = st.text_input("📚 Enter the topic you want to master:")
+    
+    if st.button("🚀 Generate Roadmap"):
+        if topic:
+            with st.spinner("🧠 Generating your personalized study roadmap..."):
+                try:
+                    logger.info(f"Starting roadmap generation for topic: {topic}")
+                    roadmap = generate_roadmap(topic)
+                    if roadmap and roadmap.steps:
+                        logger.info("Roadmap generated successfully")
+                        st.session_state.current_roadmap = roadmap
+                        st.session_state.current_topic = topic
+                        st.success("Roadmap generated successfully!")
+                    else:
+                        logger.warning("Generated roadmap is empty or invalid")
+                        st.error("Failed to generate a valid roadmap. Please try again with a different topic.")
+                except Exception as e:
+                    logger.error(f"Error during roadmap generation: {str(e)}", exc_info=True)
+                    st.error(f"An error occurred while generating the roadmap: {str(e)}")
+    
+    if 'current_roadmap' in st.session_state:
+        st.subheader(f"📊 Study Roadmap for: {st.session_state.current_topic}")
+        
+        roadmap = st.session_state.current_roadmap
+        fig = create_interactive_graph(roadmap)
+        fig.update_layout(
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            font_color='#FFFFFF'
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        user_progress = get_user_progress(roadmap)
+        
+        levels_description = {
+            "knowledge": "Understanding and remembering basic facts and concepts",
+            "comprehension": "Grasping the meaning and interpreting information",
+            "application": "Using knowledge in new situations",
+            "analysis": "Breaking information into parts and examining relationships",
+            "synthesis": "Combining elements to form a new whole",
+            "evaluation": "Making judgments based on criteria and standards"
+        }
+        
+        for level, step in roadmap.steps.items():
+            st.header(f"{level.capitalize()} Level")
+            st.write(f"**Description:** {levels_description[level]}")
+            st.write("**How to master this level:**")
+            st.write(f"To master the {level} level, focus on {levels_description[level].lower()}. Engage with the resources provided, practice applying the concepts, and gradually build your understanding. Remember that mastery at this level is crucial before moving to the next.")
+            display_step(step, level, user_progress)
+        
+        overall_progress = calculate_overall_progress(user_progress)
+        st.progress(overall_progress / 100)
+        st.write(f"Overall progress: {overall_progress:.2f}%")
+        
+        roadmap_json = json.dumps(roadmap.dict(), indent=2)
+        st.download_button(
+            label="📥 Download Roadmap as JSON",
+            data=roadmap_json,
+            file_name="study_roadmap.json",
+            mime="application/json"
+        )
+
+if __name__ == "__main__":
+    main()