Upload 13 files

app.py

@@ -0,0 +1,163 @@
+import streamlit as st
+import os
+import importlib
+
+# Custom CSS for improved styling
+def local_css(file_name):
+    with open(file_name, "r") as f:
+        st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
+
+st.set_page_config(
+    page_title="S.H.E.R.L.O.C.K.",
+    page_icon="🕵️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Define the pages with icons
+PAGES = {
+    "Home": {"icon": "🏠", "module": None},
+    "Web RAG Powered Chatbot": {"icon": "💬", "module": "chatbot"},
+    "Notes Generation": {"icon": "📝", "module": "notes_generation"},
+    "Exam Preparation": {"icon": "📚", "module": "exam_preparation"},
+    "Mnemonics Generation": {"icon": "🧠", "module": "mnemonics_generation"},
+    "Study Roadmap": {"icon": "🗺️", "module": "study_roadmap"},
+    "Interview Preparation": {"icon": "🎤", "module": "interview_preparation"},
+    "AI Buddy": {"icon": "🤖🧘", "module": "ai_buddy"},
+    "Mind Palace Builder": {"icon": "🏛️", "module": "mind_palace"},
+    "Sherlock Style Observation": {"icon": "🔍", "module": "sherlock_observation"},
+    "Research Paper Finder": {"icon": "🏛️", "module": "research_paper_finder"},
+    "Lecture Finder": {"icon": "🔍", "module": "lecture_finder"},
+    "Resume Generator": {"icon": "📝", "module": "resume_generator"}
+}
+
+def load_module(module_name):
+    if module_name is None:
+        return None
+    try:
+        return importlib.import_module(f"pages.{module_name}")
+    except ImportError:
+        st.error(f"Unable to load module: {module_name}. Make sure the file exists in the 'pages' directory.")
+        return None
+
+def main():
+    st.image("https://upload.wikimedia.org/wikipedia/commons/c/cd/Sherlock_Holmes_Portrait_Paget.jpg", use_column_width=True)
+    st.sidebar.title("S.H.E.R.L.O.C.K. 🕵️")
+    st.sidebar.markdown("*Study Helper & Educational Resource for Learning & Observational Knowledge*")
+    
+    # Apply custom CSS
+    st.markdown("""
+    <style>
+        body {
+            font-family: 'Roboto', sans-serif;
+            background-color: #f0f2f6;
+        }
+        .stButton button {
+            background-color: #0e1117;
+            color: white;
+            border-radius: 20px;
+            padding: 10px 20px;
+            font-weight: bold;
+            transition: all 0.3s ease;
+        }
+        .stButton button:hover {
+            background-color: #2e7d32;
+            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+        }
+        .sidebar .sidebar-content {
+            background-color: #0e1117;
+            color: white;
+        }
+        h1, h2, h3 {
+            color: #1e3a8a;
+        }
+        .stRadio > label {
+            font-weight: bold;
+            color: #333;
+        }
+        .feature-card {
+            background-color: white;
+            border-radius: 10px;
+            padding: 20px;
+            margin: 10px;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+            transition: all 0.3s ease;
+        }
+        .feature-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 6px 8px rgba(0,0,0,0.15);
+        }
+        .feature-icon {
+            font-size: 2em;
+            margin-bottom: 10px;
+        }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    selection = st.sidebar.radio(
+        "Navigate",
+        list(PAGES.keys()),
+        format_func=lambda x: f"{PAGES[x]['icon']} {x}"
+    )
+    
+    st.sidebar.markdown("---")
+    st.sidebar.info(
+        "This app is part of the S.H.E.R.L.O.C.K. project. "
+        "For more information, visit [our website](https://sherlock.vercel.app/)."
+    )
+    st.sidebar.text("Version 1.0")
+    
+    # Main content area
+    if selection == "Home":
+        st.title("Welcome to S.H.E.R.L.O.C.K. 🕵️")
+        st.markdown("""
+        *Systematic Holistic Educational Resource for Learning and Optimizing Cognitive Knowledge*
+        
+        S.H.E.R.L.O.C.K. is an advanced AI-powered personalized learning assistant designed to revolutionize your educational journey. By combining cutting-edge artificial intelligence with time-tested learning techniques, S.H.E.R.L.O.C.K. aims to enhance your cognitive abilities, strengthen your memory, and deepen your subject-specific knowledge.
+        
+        Our platform offers a comprehensive suite of tools and features that cater to various aspects of learning and personal development. From AI-driven chatbots and customized study plans to innovative memory techniques and mindfulness practices, S.H.E.R.L.O.C.K. is your all-in-one companion for academic success and personal growth.
+        
+        Explore our features below and embark on a journey to unlock your full learning potential!
+        """)
+        st.markdown("## Features")
+        cols = st.columns(3)
+        for idx, (feature, details) in enumerate(list(PAGES.items())[1:]):  # Skip "Home"
+            with cols[idx % 3]:
+                st.markdown(f"""
+                <div class="feature-card">
+                    <div class="feature-icon">{details['icon']}</div>
+                    <h3>{feature}</h3>
+                    <p>{get_feature_description(feature)}</p>
+                </div>
+                """, unsafe_allow_html=True)
+    else:
+        st.title(f"{PAGES[selection]['icon']} {selection}")
+        st.markdown(f"*{get_feature_description(selection)}*")
+        st.markdown("---")
+        
+        # Load and run the selected module
+        module = load_module(PAGES[selection]['module'])
+        if module and hasattr(module, 'main'):
+            module.main()
+        else:
+            st.error(f"Unable to load the {selection} feature. Please check the module implementation.")
+
+def get_feature_description(feature):
+    descriptions = {
+        "Web RAG Powered Chatbot": "Engage with our state-of-the-art AI-powered chatbot that leverages Retrieval-Augmented Generation (RAG) technology. This intelligent assistant provides interactive learning experiences by retrieving and synthesizing information from vast web-based resources, offering you accurate, context-aware responses to your queries.",
+        "Notes Generation": "Transform complex documents and lengthy lectures into concise, easy-to-understand notes. Our AI analyzes the content, extracts key points, and presents them in a clear, structured format, helping you grasp essential concepts quickly and efficiently.",
+        "Exam Preparation": "Ace your exams with our intelligent test preparation system. Generate custom question papers, practice tests, and quizzes tailored to your specific syllabus and learning progress. Receive instant feedback and targeted recommendations to improve your performance.",
+        "Mnemonics Generation": "Boost your memory and retention with personalized mnemonic devices. Our AI creates custom memory aids, including acronyms, rhymes, and vivid imagery, helping you remember complex information effortlessly and enhancing your long-term recall abilities.",
+        "Study Roadmap": "Navigate your learning journey with a personalized, adaptive study plan. Our AI analyzes your goals, strengths, and areas for improvement to create a tailored learning path, optimizing your study time and ensuring efficient progress towards your educational objectives.",
+        "Interview Preparation": "Master the art of interviewing with our advanced simulation system. Experience realistic interview scenarios, receive real-time feedback on your responses, and gain insights into improving your communication skills, body language, and overall performance.",
+        "AI Buddy": "Connect with a compassionate AI companion designed to provide emotional support, motivation, and guidance. Cultivate mental clarity and emotional balance with our curated collection of meditation and mindfulness resources. Engage in thoughtful conversations, receive personalized advice, and enjoy a judgment-free space for self-reflection and personal growth.",
+        "Mind Palace Builder": "Construct powerful mental frameworks to enhance your memory and learning capabilities. Our interactive system guides you through creating and populating your own virtual 'mind palace', allowing you to organize and recall vast amounts of information with ease.",
+        "Sherlock Style Observation": "Sharpen your critical thinking and observational skills using techniques inspired by the legendary detective. Learn to notice details, make logical deductions, and approach problems from unique perspectives, enhancing your analytical abilities across various subjects.",
+        "Research Paper Finder": "Discover relevant academic literature effortlessly with our intelligent research paper finder. Input your topic of interest, and our AI will scour databases to present you with a curated list of papers, saving you valuable research time and ensuring you stay up-to-date with the latest findings in your field.",
+        "Lecture Finder": "Expand your knowledge horizons with our smart lecture discovery tool. Find high-quality video lectures from reputable sources on YouTube, covering any topic you wish to explore. Our AI curates content based on your learning preferences and academic level.",
+        "Resume Generator": "Create a standout resume tailored to your unique skills and experiences. Our AI-powered resume generator analyzes your input and crafts a professional, ATS-friendly document that highlights your strengths and aligns with industry standards, increasing your chances of landing your dream job."
+    }
+    return descriptions.get(feature, "Description not available.")
+
+if __name__ == "__main__":
+    main()

pages/ai_buddy.py

@@ -0,0 +1,661 @@
+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 tempfile
+import time
+import numpy as np
+import threading
+from playsound import playsound
+import pygame
+import sounddevice as sd
+from scipy.io import wavfile
+
+pygame.mixer.init()
+
+# Load environment variables
+load_dotenv()
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = os.getenv('AI71_API_KEY')
+
+# 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 play_sound_loop(sound_file, stop_event):
+    while not stop_event.is_set():
+        playsound(sound_file)
+
+def play_sound_for_duration(sound_file, duration):
+    start_time = time.time()
+    while time.time() - start_time < duration:
+        playsound(sound_file, block=False)
+        time.sleep(0.1)  # Short sleep to prevent excessive CPU usage
+    # Ensure the sound stops after the duration
+    pygame.mixer.quit()
+
+def get_sound_files(directory):
+    return [f for f in os.listdir(directory) if f.endswith('.mp3')]
+
+def get_sound_file_path(sound_name, sound_dir):
+    # Convert the sound name to a filename
+    filename = f"{sound_name.lower().replace(' ', '_')}.mp3"
+    return os.path.join(sound_dir, filename)
+
+SOUND_OPTIONS = [
+    "Gentle Rain", "Ocean Waves", "Forest Ambience", "Soft Wind Chimes",
+    "Tibetan Singing Bowls", "Humming Song", "Crackling Fireplace",
+    "Birdsong", "White Noise", "Zen River", "Heartbeat", "Deep Space",
+    "Whale Songs", "Bamboo Flute", "Thunderstorm", "Cat Purring",
+    "Campfire", "Windchimes", "Waterfall", "Beach Waves", "Cicadas",
+    "Coffee Shop Ambience", "Grandfather Clock", "Rainstorm on Tent",
+    "Tropical Birds", "Subway Train", "Washing Machine", "Fan White Noise",
+    "Tibetan Bells", "Wind in Trees", "Meditation Bowl", "Meditation Bowl2", "Birds Singing Rainy Day"
+]
+
+def show_meditation_timer():
+    st.subheader("🧘‍♀️ Enhanced Meditation Timer")
+    
+    sound_dir = os.path.join(os.path.dirname(__file__), "..", "sounds")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        duration = st.slider("Select duration (minutes)", 1, 60, 5)
+        background_sound = st.selectbox("Background Sound", SOUND_OPTIONS)
+        
+    with col2:
+        interval_options = ["None", "Every 5 minutes", "Every 10 minutes"]
+        interval_reminder = st.selectbox("Interval Reminders", interval_options)
+        end_sound = st.selectbox("End of Session Sound", SOUND_OPTIONS)
+    
+    if st.button("Start Meditation", key="start_meditation"):
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        # Initialize pygame mixer
+        pygame.mixer.init()
+        
+        # Load background sound
+        background_sound_file = get_sound_file_path(background_sound, sound_dir)
+        if not os.path.exists(background_sound_file):
+            st.error(f"Background sound file not found: {background_sound_file}")
+            return
+        
+        # Load end of session sound
+        end_sound_file = get_sound_file_path(end_sound, sound_dir)
+        if not os.path.exists(end_sound_file):
+            st.error(f"End sound file not found: {end_sound_file}")
+            return
+        
+        # Play background sound on loop
+        pygame.mixer.music.load(background_sound_file)
+        pygame.mixer.music.play(-1)  # -1 means loop indefinitely
+        
+        start_time = time.time()
+        end_time = start_time + (duration * 60)
+        
+        try:
+            while time.time() < end_time:
+                elapsed_time = time.time() - start_time
+                progress = elapsed_time / (duration * 60)
+                progress_bar.progress(progress)
+                
+                remaining_time = end_time - time.time()
+                mins, secs = divmod(int(remaining_time), 60)
+                status_text.text(f"Time remaining: {mins:02d}:{secs:02d}")
+                
+                if interval_reminder != "None":
+                    interval = 5 if interval_reminder == "Every 5 minutes" else 10
+                    if int(elapsed_time) > 0 and int(elapsed_time) % (interval * 60) == 0:
+                        st.toast(f"{interval} minutes passed", icon="⏰")
+                
+                # Check if 10 seconds remaining
+                if remaining_time <= 10 and remaining_time > 9:
+                    pygame.mixer.music.stop()  # Stop background sound
+                    pygame.mixer.Sound(end_sound_file).play()  # Play end sound
+                
+                if remaining_time <= 0:
+                    break
+                
+                time.sleep(0.1)  # Update more frequently for smoother countdown
+        finally:
+            # Stop all sounds
+            pygame.mixer.quit()
+        
+        # Ensure the progress bar is full and time remaining shows 00:00
+        progress_bar.progress(1.0)
+        status_text.text("Time remaining: 00:00")
+        
+        st.success("Meditation complete!")
+        st.balloons()
+        
+        if 'achievements' not in st.session_state:
+            st.session_state.achievements = set()
+        st.session_state.achievements.add("Zen Master")
+        st.success("Achievement Unlocked: Zen Master 🧘‍♀️")
+
+def show_personalized_recommendations():
+    st.subheader("🎯 Personalized Recommendations")
+    
+    recommendation_categories = [
+        "Mental Health",
+        "Physical Health",
+        "Personal Development",
+        "Relationships",
+        "Career",
+        "Hobbies",
+    ]
+    
+    selected_category = st.selectbox("Choose a category", recommendation_categories)
+    
+    recommendations = {
+        "Mental Health": [
+            "Practice daily gratitude journaling",
+            "Try a guided meditation for stress relief",
+            "Explore cognitive behavioral therapy techniques",
+            "Start a mood tracking journal",
+            "Learn about mindfulness practices",
+        ],
+        "Physical Health": [
+            "Start a 30-day yoga challenge",
+            "Try intermittent fasting",
+            "Begin a couch to 5K running program",
+            "Experiment with new healthy recipes",
+            "Create a sleep hygiene routine",
+        ],
+        "Personal Development": [
+            "Start learning a new language",
+            "Read personal development books",
+            "Take an online course in a subject you're interested in",
+            "Practice public speaking",
+            "Start a daily writing habit",
+        ],
+        "Relationships": [
+            "Practice active listening techniques",
+            "Plan regular date nights or friend meetups",
+            "Learn about love languages",
+            "Practice expressing gratitude to loved ones",
+            "Join a local community or interest group",
+        ],
+        "Career": [
+            "Update your resume and LinkedIn profile",
+            "Network with professionals in your industry",
+            "Set SMART career goals",
+            "Learn a new skill relevant to your field",
+            "Start a side project or freelance work",
+        ],
+        "Hobbies": [
+            "Start a garden or learn about plant care",
+            "Try a new art form like painting or sculpting",
+            "Learn to play a musical instrument",
+            "Start a DIY home improvement project",
+            "Explore photography or videography",
+        ],
+    }
+    
+    st.write("Here are some personalized recommendations for you:")
+    for recommendation in recommendations[selected_category]:
+        st.markdown(f"- {recommendation}")
+    
+    if st.button("Get More Recommendations"):
+        st.write("More tailored recommendations:")
+        additional_recs = random.sample(recommendations[selected_category], 3)
+        for rec in additional_recs:
+            st.markdown(f"- {rec}")
+
+def generate_binaural_beat(freq1, freq2, duration_seconds, sample_rate=44100):
+    t = np.linspace(0, duration_seconds, int(sample_rate * duration_seconds), False)
+    left_channel = np.sin(2 * np.pi * freq1 * t)
+    right_channel = np.sin(2 * np.pi * freq2 * t)
+    stereo_audio = np.vstack((left_channel, right_channel)).T
+    return (stereo_audio * 32767).astype(np.int16)
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    b64 = base64.b64encode(bin_file).decode()
+    return f'<a href="data:application/octet-stream;base64,{b64}" download="{file_label}.wav" class="download-link">Download {file_label}</a>'
+
+def show_binaural_beats():
+    st.subheader("🎵 Binaural Beats Generator")
+    
+    st.markdown("""
+    <style>
+    .stButton>button {
+        background-color: #4CAF50;
+        color: white;
+        font-weight: bold;
+    }
+    .download-link {
+        background-color: #008CBA;
+        color: white;
+        padding: 10px 15px;
+        text-align: center;
+        text-decoration: none;
+        display: inline-block;
+        font-size: 16px;
+        margin: 4px 2px;
+        cursor: pointer;
+        border-radius: 4px;
+    }
+    .stop-button {
+        background-color: #f44336;
+        color: white;
+        font-weight: bold;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    st.write("Binaural beats are created when two slightly different frequencies are played in each ear, potentially influencing brainwave activity.")
+    
+    preset_beats = {
+        "Deep Relaxation (Delta)": {"base": 100, "beat": 2},
+        "Meditation (Theta)": {"base": 150, "beat": 6},
+        "Relaxation (Alpha)": {"base": 200, "beat": 10},
+        "Light Focus (Low Beta)": {"base": 250, "beat": 14},
+        "High Focus (Mid Beta)": {"base": 300, "beat": 20},
+        "Alertness (High Beta)": {"base": 350, "beat": 30},
+        "Gamma Consciousness": {"base": 400, "beat": 40},
+        "Lucid Dreaming": {"base": 180, "beat": 3},
+        "Memory Enhancement": {"base": 270, "beat": 12},
+        "Creativity Boost": {"base": 220, "beat": 8},
+        "Pain Relief": {"base": 130, "beat": 4},
+        "Mood Elevation": {"base": 315, "beat": 18}
+    }
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        beat_type = st.selectbox("Choose a preset or custom:", ["Custom"] + list(preset_beats.keys()))
+    
+    with col2:
+        duration = st.slider("Duration (minutes):", 1, 60, 15)
+    
+    if beat_type == "Custom":
+        col3, col4 = st.columns(2)
+        with col3:
+            base_freq = st.slider("Base Frequency (Hz):", 100, 500, 200)
+        with col4:
+            beat_freq = st.slider("Desired Beat Frequency (Hz):", 1, 40, 10)
+    else:
+        base_freq = preset_beats[beat_type]["base"]
+        beat_freq = preset_beats[beat_type]["beat"]
+        st.info(f"Base Frequency: {base_freq} Hz, Beat Frequency: {beat_freq} Hz")
+    
+    if 'audio_playing' not in st.session_state:
+        st.session_state.audio_playing = False
+    
+    if 'start_time' not in st.session_state:
+        st.session_state.start_time = None
+    
+    if 'end_time' not in st.session_state:
+        st.session_state.end_time = None
+    
+    # Create persistent placeholders for UI elements
+    progress_bar = st.empty()
+    status_text = st.empty()
+    stop_button = st.empty()
+    
+    generate_button = st.button("Generate and Play Binaural Beat")
+    
+    if generate_button:
+        try:
+            # Stop any currently playing audio
+            if st.session_state.audio_playing:
+                pygame.mixer.music.stop()
+                st.session_state.audio_playing = False
+            
+            audio_data = generate_binaural_beat(base_freq, base_freq + beat_freq, duration * 60)
+            
+            # Save the generated audio to a temporary file
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_file:
+                temp_filename = temp_file.name
+                wavfile.write(temp_filename, 44100, audio_data)
+            
+            # Initialize pygame mixer
+            pygame.mixer.init(frequency=44100, size=-16, channels=2)
+            
+            # Load and play the audio
+            pygame.mixer.music.load(temp_filename)
+            pygame.mixer.music.play()
+            st.session_state.audio_playing = True
+            
+            st.session_state.start_time = time.time()
+            st.session_state.end_time = st.session_state.start_time + (duration * 60)
+        
+        except Exception as e:
+            st.error(f"An error occurred: {str(e)}")
+            st.info("Please try again or contact support if the issue persists.")
+    
+    if st.session_state.audio_playing:
+        stop_button_active = stop_button.button("Stop Binaural Beat", key="stop_binaural", type="primary")
+        current_time = time.time()
+        
+        if stop_button_active:
+            pygame.mixer.music.stop()
+            st.session_state.audio_playing = False
+            st.session_state.start_time = None
+            st.session_state.end_time = None
+        
+        elif current_time < st.session_state.end_time:
+            elapsed_time = current_time - st.session_state.start_time
+            progress = elapsed_time / (st.session_state.end_time - st.session_state.start_time)
+            progress_bar.progress(progress)
+            
+            remaining_time = st.session_state.end_time - current_time
+            mins, secs = divmod(int(remaining_time), 60)
+            status_text.text(f"Time remaining: {mins:02d}:{secs:02d}")
+        else:
+            pygame.mixer.music.stop()
+            st.session_state.audio_playing = False
+            st.session_state.start_time = None
+            st.session_state.end_time = None
+            progress_bar.empty()
+            status_text.text("Binaural beat session complete!")
+    
+    # Offer download of the generated audio
+    if not st.session_state.audio_playing and 'audio_data' in locals():
+        with io.BytesIO() as buffer:
+            wavfile.write(buffer, 44100, audio_data)
+            st.markdown(get_binary_file_downloader_html(buffer.getvalue(), f"binaural_beat_{base_freq}_{beat_freq}Hz"), unsafe_allow_html=True)
+
+    # Ensure the app updates every second
+    if st.session_state.audio_playing:
+        time.sleep(1)
+        st.experimental_rerun()
+
+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 and additional features
+    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.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")
+        
+        st.markdown("---")
+        st.markdown("Powered by Falcon-180B and Streamlit")
+
+        st.markdown("---")
+        st.header("📔 Daily Journal")
+        journal_entry = st.text_area("Write your thoughts for today")
+        if st.button("Save Journal Entry"):
+            if 'journal_entries' not in st.session_state:
+                st.session_state.journal_entries = []
+            st.session_state.journal_entries.append({
+                'date': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                'entry': journal_entry
+            })
+            st.success("Journal entry saved!")
+            st.toast("Journal entry saved successfully!", icon="✅")
+        
+        if 'journal_entries' in st.session_state and st.session_state.journal_entries:
+            st.subheader("Previous Entries")
+            for entry in st.session_state.journal_entries[-5:]:  # Show last 5 entries
+                st.text(entry['date'])
+                st.write(entry['entry'])
+                st.markdown("---")
+
+    # Main content area
+    tab1, tab2 = st.tabs(["Chat", "Tools"])
+    
+    with tab1:
+        # Chat interface
+        st.header("🗨️ Chat with Your AI Buddy")
+        
+        # Display chat history
+        chat_container = st.container()
+        with chat_container:
+            for message in st.session_state.messages:
+                with st.chat_message(message["role"]):
+                    st.markdown(message["content"])
+        
+        # User input
+        prompt = st.chat_input("What's on your mind?")
+        
+        # Clear chat history button
+        if st.button("Clear Chat History"):
+            st.session_state.messages = []
+            st.experimental_rerun()
+
+        if prompt:
+            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})
+
+            # Force a rerun to update the chat history immediately
+            st.experimental_rerun()
+
+    with tab2:
+        tool_choice = st.selectbox("Select a tool", ["Meditation Timer", "Binaural Beats", "Recommendations"])
+        if tool_choice == "Meditation Timer":
+            show_meditation_timer()
+        elif tool_choice == "Recommendations":
+            show_personalized_recommendations()
+        elif tool_choice == "Binaural Beats":
+            show_binaural_beats()
+
+    # 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()
+
+    # 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",
+            "Do not wait to strike till the iron is hot; but make it hot by striking. - William Butler Yeats",
+            "What lies behind us and what lies before us are tiny matters compared to what lies within us. - Ralph Waldo Emerson",
+            "Success is not final, failure is not fatal: It is the courage to continue that counts. - Winston Churchill",
+            "Life is what happens when you're busy making other plans. - John Lennon",
+            "You miss 100% of the shots you don't take. - Wayne Gretzky",
+            "The best way to predict the future is to create it. - Peter Drucker",
+            "It is not the strongest of the species that survive, nor the most intelligent, but the one most responsive to change. - Charles Darwin",
+            "Whether you think you can or you think you can't, you're right. - Henry Ford",
+            "The only place where success comes before work is in the dictionary. - Vidal Sassoon",
+            "Do what you can, with what you have, where you are. - Theodore Roosevelt",
+            "The purpose of our lives is to be happy. - Dalai Lama",
+            "Success usually comes to those who are too busy to be looking for it. - Henry David Thoreau",
+            "Your time is limited, so don't waste it living someone else's life. - Steve Jobs",
+            "Don't be afraid to give up the good to go for the great. - John D. Rockefeller",
+            "I find that the harder I work, the more luck I seem to have. - Thomas Jefferson",
+            "Success is not the key to happiness. Happiness is the key to success. - Albert Schweitzer",
+            "It does not matter how slowly you go, as long as you do not stop. - Confucius",
+            "If you set your goals ridiculously high and it's a failure, you will fail above everyone else's success. - James Cameron",
+            "Don't watch the clock; do what it does. Keep going. - Sam Levenson",
+            "Hardships often prepare ordinary people for an extraordinary destiny. - C.S. Lewis",
+            "Don't count the days, make the days count. - Muhammad Ali",
+            "The best revenge is massive success. - Frank Sinatra",
+            "The only impossible journey is the one you never begin. - Tony Robbins",
+            "Act as if what you do makes a difference. It does. - William James",
+            "You are never too old to set another goal or to dream a new dream. - C.S. Lewis",
+            "If you're going through hell, keep going. - Winston Churchill",
+            "Dream big and dare to fail. - Norman Vaughan",
+            "In the middle of every difficulty lies opportunity. - Albert Einstein",
+            "What we achieve inwardly will change outer reality. - Plutarch",
+            "I have not failed. I've just found 10,000 ways that won't work. - Thomas Edison",
+            "It always seems impossible until it's done. - Nelson Mandela",
+            "The future depends on what you do today. - Mahatma Gandhi",
+            "Don't wait. The time will never be just right. - Napoleon Hill",
+            "Quality is not an act, it is a habit. - Aristotle",
+            "Your life does not get better by chance, it gets better by change. - Jim Rohn",
+            "The only thing standing between you and your goal is the story you keep telling yourself as to why you can't achieve it. - Jordan Belfort",
+            "Challenges are what make life interesting; overcoming them is what makes life meaningful. - Joshua J. Marine",
+            "Opportunities don't happen, you create them. - Chris Grosser",
+            "I can't change the direction of the wind, but I can adjust my sails to always reach my destination. - Jimmy Dean",
+            "Start where you are. Use what you have. Do what you can. - Arthur Ashe",
+            "The secret of getting ahead is getting started. - Mark Twain",
+            "You don’t have to be great to start, but you have to start to be great. - Zig Ziglar",
+            "Keep your eyes on the stars, and your feet on the ground. - Theodore Roosevelt",
+            "The only way to achieve the impossible is to believe it is possible. - Charles Kingsleigh"
+        ]
+
+        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!")
+
+    # Display achievements
+    if 'achievements' in st.session_state and st.session_state.achievements:
+        st.sidebar.markdown("---")
+        st.sidebar.header("🏆 Achievements")
+        for achievement in st.session_state.achievements:
+            st.sidebar.success(f"Unlocked: {achievement}")
+
+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 = os.getenv('AI71_API_KEY')
+
+# 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 = os.getenv('api_key')
+    cse_id = os.getenv('cse_id')
+    
+    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_community.chat_models 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 = os.getenv('AI71_API_KEY')
+GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
+GOOGLE_CSE_ID = os.getenv('GOOGLE_CSE_ID')
+YOUTUBE_API_KEY = os.getenv('YOUTUBE_API_KEY')
+
+# 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 = os.getenv('AI71_API_KEY')
+
+# 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/lecture_finder.py

@@ -0,0 +1,123 @@
+import streamlit as st
+import googleapiclient.discovery
+from dotenv import load_dotenv
+from datetime import timedelta
+
+# Load environment variables
+load_dotenv()
+
+# Set up YouTube API client
+api_service_name = "youtube"
+api_version = "v3"
+DEVELOPER_KEY = os.getenv('DEVELOPER_KEY')
+youtube = googleapiclient.discovery.build(api_service_name, api_version, developerKey=DEVELOPER_KEY)
+
+def search_youtube(query, max_results=50):
+    try:
+        request = youtube.search().list(
+            q=query,
+            type="video",
+            part="id,snippet",
+            maxResults=max_results,
+            fields="items(id(videoId),snippet(title,description,thumbnails))"
+        )
+        response = request.execute()
+        return response.get('items', [])
+    except googleapiclient.errors.HttpError as e:
+        st.error(f"An error occurred: {e}")
+        return []
+
+def get_video_details(video_id):
+    try:
+        request = youtube.videos().list(
+            part="contentDetails,statistics",
+            id=video_id,
+            fields="items(contentDetails(duration),statistics(viewCount))"
+        )
+        response = request.execute()
+        return response['items'][0] if response['items'] else None
+    except googleapiclient.errors.HttpError as e:
+        st.error(f"An error occurred while fetching video details: {e}")
+        return None
+
+def format_duration(duration):
+    duration = duration.replace('PT', '')
+    hours = 0
+    minutes = 0
+    seconds = 0
+    if 'H' in duration:
+        hours, duration = duration.split('H')
+        hours = int(hours)
+    if 'M' in duration:
+        minutes, duration = duration.split('M')
+        minutes = int(minutes)
+    if 'S' in duration:
+        seconds = int(duration.replace('S', ''))
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+def parse_duration(duration_str):
+    parts = duration_str.split(':')
+    if len(parts) == 3:
+        return timedelta(hours=int(parts[0]), minutes=int(parts[1]), seconds=int(parts[2]))
+    elif len(parts) == 2:
+        return timedelta(minutes=int(parts[0]), seconds=int(parts[1]))
+    else:
+        return timedelta(seconds=int(parts[0]))
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. Learning Assistant", page_icon="🕵️", layout="wide")
+    st.sidebar.title("S.H.E.R.L.O.C.K.")
+    st.sidebar.markdown("""
+    **S**ystematic **H**olistic **E**ducational **R**esource for **L**earning and **O**ptimizing **C**ognitive **K**nowledge
+    
+    Enhance your cognitive abilities, memory techniques, and subject-specific knowledge with AI-powered personalized learning.
+    """)
+    
+    query = st.sidebar.text_input("What would you like to learn about?", "")
+    
+    min_duration = st.sidebar.selectbox(
+        "Minimum video duration",
+        ["Any", "5:00", "10:00", "15:00", "30:00", "45:00", "1:00:00"],
+        index=0
+    )
+    
+    search_button = st.sidebar.button("Search for Learning Resources")
+    
+    st.title("Learning Resources")
+    
+    if search_button and query:
+        with st.spinner("Searching for the best learning resources..."):
+            results = search_youtube(query)
+            
+        if results:
+            filtered_results = []
+            for item in results:
+                video_id = item['id']['videoId']
+                video_details = get_video_details(video_id)
+                
+                if video_details:
+                    duration = video_details['contentDetails']['duration']
+                    formatted_duration = format_duration(duration)
+                    views = int(video_details['statistics']['viewCount'])
+                    
+                    if min_duration == "Any" or parse_duration(formatted_duration) >= parse_duration(min_duration):
+                        filtered_results.append((item, formatted_duration, views))
+                
+            if filtered_results:
+                for item, duration, views in filtered_results:
+                    col1, col2 = st.columns([1, 3])
+                    with col1:
+                        st.image(item['snippet']['thumbnails']['medium']['url'], use_column_width=True)
+                    with col2:
+                        st.markdown(f"### [{item['snippet']['title']}](https://www.youtube.com/watch?v={item['id']['videoId']})")
+                        st.markdown(f"**Duration:** {duration} | **Views:** {views:,}")
+                        st.markdown(item['snippet']['description'])
+                    
+                    st.markdown("---")
+            else:
+                st.warning("No results found matching your duration criteria. Try adjusting the minimum duration or search query.")
+        else:
+            st.warning("No results found. Please try a different search query.")
+
+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 = os.getenv('AI71_API_KEY')
+
+# 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 = os.getenv('AI71_API_KEY')
+
+# 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 = os.getenv('AI71_API_KEY')
+
+# 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/research_paper_finder.py

@@ -0,0 +1,135 @@
+import streamlit as st
+import requests
+from datetime import datetime, timedelta
+import pandas as pd
+from dotenv import load_dotenv
+import os
+
+# Load environment variables
+load_dotenv()
+
+# Scopus API key
+SCOPUS_API_KEY = "8e94f85eb6044ef1cde06e8b5a426a09"
+
+def search_scopus(query, start_year, end_year, max_results=50):
+    base_url = "https://api.elsevier.com/content/search/scopus"
+    
+    params = {
+        "query": query,
+        "date": f"{start_year}-{end_year}",
+        "count": max_results,
+        "sort": "citedby-count desc",
+        "field": "title,author,year,publicationName,description,citedby-count,doi,eid"
+    }
+    
+    headers = {
+        "X-ELS-APIKey": SCOPUS_API_KEY,
+        "Accept": "application/json"
+    }
+    
+    try:
+        response = requests.get(base_url, params=params, headers=headers)
+        response.raise_for_status()
+        return response.json()["search-results"]["entry"]
+    except requests.exceptions.RequestException as e:
+        st.error(f"An error occurred while searching Scopus: {e}")
+        return []
+
+def format_authors(author_info):
+    if isinstance(author_info, list):
+        return ", ".join([author.get("authname", "") for author in author_info])
+    elif isinstance(author_info, dict):
+        return author_info.get("authname", "")
+    else:
+        return "N/A"
+
+def safe_get(dictionary, keys, default="N/A"):
+    for key in keys:
+        if isinstance(dictionary, dict) and key in dictionary:
+            dictionary = dictionary[key]
+        else:
+            return default
+    return dictionary
+
+def get_paper_link(paper):
+    doi = safe_get(paper, ["prism:doi"])
+    if doi != "N/A":
+        return f"https://doi.org/{doi}"
+    eid = safe_get(paper, ["eid"])
+    if eid != "N/A":
+        return f"https://www.scopus.com/record/display.uri?eid={eid}&origin=resultslist"
+    return "#"
+
+def main():
+    st.set_page_config(page_title="S.H.E.R.L.O.C.K. Research Assistant", page_icon="🔬", layout="wide")
+    
+    st.sidebar.title("S.H.E.R.L.O.C.K.")
+    st.sidebar.markdown("""
+    **S**ystematic **H**olistic **E**ducational **R**esource for **L**iterature and **O**ptimizing **C**ognitive **K**nowledge
+    
+    Enhance your research capabilities with AI-powered literature search and analysis.
+    """)
+    
+    query = st.sidebar.text_input("What topic would you like to research?", "")
+    
+    current_year = datetime.now().year
+    start_year, end_year = st.sidebar.slider(
+        "Publication Year Range",
+        min_value=1900,
+        max_value=current_year,
+        value=(current_year-5, current_year)
+    )
+    
+    max_results = st.sidebar.slider("Maximum number of results", 10, 100, 50)
+    
+    search_button = st.sidebar.button("Search for Research Papers")
+    
+    st.title("Research Papers and Articles")
+    
+    if search_button and query:
+        with st.spinner("Searching for the most relevant research papers..."):
+            results = search_scopus(query, start_year, end_year, max_results)
+        
+        if results:
+            papers = []
+            for paper in results:
+                papers.append({
+                    "Title": safe_get(paper, ["dc:title"]),
+                    "Authors": format_authors(safe_get(paper, ["author"])),
+                    "Year": safe_get(paper, ["prism:coverDate"])[:4],
+                    "Journal": safe_get(paper, ["prism:publicationName"]),
+                    "Abstract": safe_get(paper, ["dc:description"]),
+                    "Citations": safe_get(paper, ["citedby-count"], "0"),
+                    "Link": get_paper_link(paper)
+                })
+            
+            df = pd.DataFrame(papers)
+            
+            st.markdown(f"### Found {len(results)} papers on '{query}'")
+            
+            for _, paper in df.iterrows():
+                with st.container():
+                    col1, col2 = st.columns([3, 1])
+                    with col1:
+                        st.markdown(f"#### [{paper['Title']}]({paper['Link']})")
+                        st.markdown(f"**Authors:** {paper['Authors']}")
+                        st.markdown(f"**Published in:** {paper['Journal']} ({paper['Year']})")
+                        st.markdown(f"**Abstract:** {paper['Abstract']}")
+                    with col2:
+                        st.metric("Citations", paper["Citations"])
+                    
+                    st.markdown("---")
+            
+            # Download results as CSV
+            csv = df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Download results as CSV",
+                data=csv,
+                file_name=f"{query.replace(' ', '_')}_research_papers.csv",
+                mime="text/csv",
+            )
+        else:
+            st.warning("No results found. Please try a different search query or adjust the year range.")
+
+if __name__ == "__main__":
+    main()

pages/resume_generator.py

@@ -0,0 +1,454 @@
+import streamlit as st
+import base64
+from io import BytesIO
+from datetime import datetime
+import json
+from docx import Document
+from docx.shared import Inches, Pt
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
+from reportlab.lib import colors
+from langchain.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage
+from PIL import Image as PILImage
+
+AI71_BASE_URL = "https://api.ai71.ai/v1/"
+AI71_API_KEY = os.getenv('AI71_API_KEY')
+
+def get_llm():
+    return ChatOpenAI(
+        model="tiiuae/falcon-180B-chat",
+        api_key=AI71_API_KEY,
+        base_url=AI71_BASE_URL,
+        streaming=True,
+    )
+
+def generate_resume_content(resume_data):
+    llm = get_llm()
+    
+    prompt = f"""
+    Generate a highly professional and ATS-optimized resume based on the following information:
+    
+    Name: {resume_data['name']}
+    Email: {resume_data['email']}
+    Phone: {resume_data['phone']}
+    Location: {resume_data['location']}
+    
+    Work Experience:
+    {json.dumps(resume_data['work_experience'], indent=2)}
+    
+    Education:
+    {json.dumps(resume_data['education'], indent=2)}
+    
+    Skills: {', '.join(resume_data['skills'])}
+    
+    Please generate a compelling professional summary and enhance the job descriptions. 
+    Use action verbs, quantify achievements where possible, and highlight key skills.
+    Ensure the content is tailored for ATS optimization.
+    The output should be in JSON format with the following structure:
+    {{
+        "summary": "Professional summary here",
+        "work_experience": [
+            {{
+                "title": "Job title",
+                "company": "Company name",
+                "start_date": "Start date",
+                "end_date": "End date",
+                "description": "Enhanced job description with bullet points"
+            }}
+        ]
+    }}
+    """
+    
+    try:
+        response = llm([HumanMessage(content=prompt)])
+        enhanced_content = json.loads(response.content)
+        
+        resume_data['summary'] = enhanced_content['summary']
+        resume_data['work_experience'] = enhanced_content['work_experience']
+        
+        return resume_data
+    except Exception as e:
+        st.error(f"An error occurred while generating AI content: {str(e)}")
+        return resume_data
+
+def create_docx(resume_data):
+    doc = Document()
+    
+    # Styles
+    styles = doc.styles
+    style = styles.add_style('Name', 1)
+    style.font.name = 'Calibri'
+    style.font.size = Pt(24)
+    style.font.bold = True
+    style.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    
+    # Add photo if provided
+    if 'photo' in resume_data and resume_data['photo']:
+        image_stream = BytesIO(resume_data['photo'])
+        doc.add_picture(image_stream, width=Inches(2.0))
+    
+    # Add name
+    doc.add_paragraph(resume_data['name'], style='Name')
+    
+    # Add contact information
+    contact_info = doc.add_paragraph()
+    contact_info.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    contact_info.add_run(f"{resume_data['email']} | {resume_data['phone']} | {resume_data['location']}")
+    
+    # Add summary
+    doc.add_heading('Professional Summary', level=1)
+    doc.add_paragraph(resume_data['summary'])
+    
+    # Add work experience
+    doc.add_heading('Work Experience', level=1)
+    for job in resume_data['work_experience']:
+        p = doc.add_paragraph(f"{job['title']} at {job['company']}", style='Heading 2')
+        p.add_run(f"\n{job['start_date']} - {job['end_date']}")
+        for bullet in job['description'].split('\n'):
+            if bullet.strip():
+                doc.add_paragraph(bullet.strip(), style='List Bullet')
+    
+    # Add education
+    doc.add_heading('Education', level=1)
+    for edu in resume_data['education']:
+        p = doc.add_paragraph(f"{edu['degree']} in {edu['field']}", style='Heading 2')
+        p.add_run(f"\n{edu['institution']}, {edu['graduation_date']}")
+    
+    # Add skills
+    doc.add_heading('Skills', level=1)
+    doc.add_paragraph(', '.join(resume_data['skills']))
+    
+    buffer = BytesIO()
+    doc.save(buffer)
+    buffer.seek(0)
+    return buffer
+
+def create_pdf(resume_data):
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=letter, rightMargin=72, leftMargin=72, topMargin=72, bottomMargin=18)
+    
+    styles = getSampleStyleSheet()
+    styles.add(ParagraphStyle(name='Justify', alignment=TA_JUSTIFY))
+    styles.add(ParagraphStyle(name='Center', alignment=TA_CENTER))
+    
+    story = []
+    
+    # Add photo if provided
+    if 'photo' in resume_data and resume_data['photo']:
+        image_stream = BytesIO(resume_data['photo'])
+        img = Image(image_stream, width=100, height=100)
+        story.append(img)
+    
+    # Add name
+    story.append(Paragraph(resume_data['name'], styles['Title']))
+    
+    # Add contact information
+    story.append(Paragraph(f"{resume_data['email']} | {resume_data['phone']} | {resume_data['location']}", styles['Center']))
+    story.append(Spacer(1, 12))
+    
+    # Add summary
+    story.append(Paragraph('Professional Summary', styles['Heading1']))
+    story.append(Paragraph(resume_data['summary'], styles['Justify']))
+    story.append(Spacer(1, 12))
+    
+    # Add work experience
+    story.append(Paragraph('Work Experience', styles['Heading1']))
+    for job in resume_data['work_experience']:
+        story.append(Paragraph(f"{job['title']} at {job['company']}", styles['Heading2']))
+        story.append(Paragraph(f"{job['start_date']} - {job['end_date']}", styles['Normal']))
+        for bullet in job['description'].split('\n'):
+            if bullet.strip():
+                story.append(Paragraph(f"• {bullet.strip()}", styles['Normal']))
+        story.append(Spacer(1, 12))
+    
+    # Add education
+    story.append(Paragraph('Education', styles['Heading1']))
+    for edu in resume_data['education']:
+        story.append(Paragraph(f"{edu['degree']} in {edu['field']}", styles['Heading2']))
+        story.append(Paragraph(f"{edu['institution']}, {edu['graduation_date']}", styles['Normal']))
+        story.append(Spacer(1, 12))
+    
+    # Add skills
+    story.append(Paragraph('Skills', styles['Heading1']))
+    story.append(Paragraph(', '.join(resume_data['skills']), styles['Normal']))
+    
+    doc.build(story)
+    buffer.seek(0)
+    return buffer
+
+def create_txt(resume_data):
+    txt_content = f"{resume_data['name']}\n"
+    txt_content += f"{resume_data['email']} | {resume_data['phone']} | {resume_data['location']}\n\n"
+    
+    txt_content += "Professional Summary\n"
+    txt_content += f"{resume_data['summary']}\n\n"
+    
+    txt_content += "Work Experience\n"
+    for job in resume_data['work_experience']:
+        txt_content += f"{job['title']} at {job['company']}\n"
+        txt_content += f"{job['start_date']} - {job['end_date']}\n"
+        for bullet in job['description'].split('\n'):
+            if bullet.strip():
+                txt_content += f"• {bullet.strip()}\n"
+        txt_content += "\n"
+    
+    txt_content += "Education\n"
+    for edu in resume_data['education']:
+        txt_content += f"{edu['degree']} in {edu['field']}\n"
+        txt_content += f"{edu['institution']}, {edu['graduation_date']}\n\n"
+    
+    txt_content += "Skills\n"
+    txt_content += ', '.join(resume_data['skills'])
+    
+    return txt_content.encode()
+
+def calculate_ats_score(resume_data):
+    score = 0
+    max_score = 100
+    
+    # Check for key sections
+    if resume_data['name']: score += 5
+    if resume_data['email']: score += 5
+    if resume_data['phone']: score += 5
+    if resume_data['location']: score += 5
+    if resume_data['summary']: score += 10
+    if resume_data['work_experience']: score += 20
+    if resume_data['education']: score += 15
+    if resume_data['skills']: score += 15
+    
+    # Check content quality
+    if len(resume_data['summary'].split()) >= 50: score += 5
+    if len(resume_data['work_experience']) >= 2: score += 5
+    if len(resume_data['skills']) >= 5: score += 5
+    
+    # Check for keywords (this is a simplified version, in reality, you'd want to check against job-specific keywords)
+    keywords = ['experience', 'skills', 'project', 'team', 'leadership', 'communication', 'achieved', 'improved', 'managed', 'developed']
+    resume_text = ' '.join([str(value) for value in resume_data.values() if isinstance(value, str)])
+    for keyword in keywords:
+        if keyword in resume_text.lower():
+            score += 1
+    
+    return min(score, max_score)
+
+def main():
+    st.set_page_config(page_title="AI-Enhanced Resume Builder", page_icon="📄", layout="wide")
+    
+    st.markdown("""
+    <style>
+    .big-font {
+        font-size:30px !important;
+        font-weight: bold;
+    }
+    .stButton>button {
+        width: 100%;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    # Add sidebar
+    st.sidebar.title("About This Project")
+    st.sidebar.write("""
+    Welcome to the AI-Enhanced Resume Builder!
+
+    This project helps you create a professional, ATS-optimized resume with the power of AI. Here's what you can do:
+
+    1. Input your personal information
+    2. Add your work experience
+    3. Include your education details
+    4. List your skills
+    5. Optionally upload a photo
+    6. Generate AI-enhanced content
+    7. Review and download your resume
+
+    The AI will help improve your resume content and provide an ATS compatibility score.
+
+    Get started by filling out the form and clicking 'Next' at each step!
+    """)
+    
+    st.markdown('<p class="big-font">AI-Enhanced Resume Builder</p>', unsafe_allow_html=True)
+    st.write("Create a professional, ATS-optimized resume with AI-powered content enhancement")
+    
+    # Initialize session state
+    if 'step' not in st.session_state:
+        st.session_state.step = 1
+    
+    if 'resume_data' not in st.session_state:
+        st.session_state.resume_data = {
+            'name': '', 'email': '', 'phone': '', 'location': '',
+            'summary': '', 'work_experience': [], 'education': [], 'skills': [], 'photo': None
+        }
+    
+    # Step 1: Personal Information
+    if st.session_state.step == 1:
+        st.subheader("Step 1: Personal Information")
+        name = st.text_input("Full Name", st.session_state.resume_data['name'])
+        email = st.text_input("Email", st.session_state.resume_data['email'])
+        phone = st.text_input("Phone", st.session_state.resume_data['phone'])
+        location = st.text_input("Location", st.session_state.resume_data['location'])
+        
+        photo_upload = st.file_uploader("Upload a photo (optional)", type=['jpg', 'jpeg', 'png'])
+        if photo_upload:
+            image = PILImage.open(photo_upload)
+            st.image(image, caption='Uploaded Image', use_column_width=True)
+            buffered = BytesIO()
+            image.save(buffered, format="PNG")
+            st.session_state.resume_data['photo'] = buffered.getvalue()
+        
+        if st.button("Next"):
+            if name and email and phone and location:
+                st.session_state.resume_data.update({
+                    'name': name,
+                    'email': email,
+                    'phone': phone,
+                    'location': location
+                })
+                st.session_state.step = 2
+            else:
+                st.error("Please fill in all required fields before proceeding.")
+    
+    # Step 2: Work Experience
+    elif st.session_state.step == 2:
+        st.subheader("Step 2: Work Experience")
+        num_jobs = st.number_input("Number of jobs to add", min_value=1, max_value=10, value=len(st.session_state.resume_data['work_experience']) or 1)
+        
+        work_experience = []
+        for i in range(num_jobs):
+            st.write(f"Job {i+1}")
+            job = {}
+            job['title'] = st.text_input(f"Job Title {i+1}", st.session_state.resume_data['work_experience'][i]['title'] if i < len(st.session_state.resume_data['work_experience']) else '')
+            job['company'] = st.text_input(f"Company {i+1}", st.session_state.resume_data['work_experience'][i]['company'] if i < len(st.session_state.resume_data['work_experience']) else '')
+            job['start_date'] = st.date_input(f"Start Date {i+1}", value=datetime.strptime(st.session_state.resume_data['work_experience'][i]['start_date'] if i < len(st.session_state.resume_data['work_experience']) else '2020-01-01', '%Y-%m-%d')).strftime('%Y-%m-%d')
+            job['end_date'] = st.date_input(f"End Date {i+1}", value=datetime.strptime(st.session_state.resume_data['work_experience'][i]['end_date'] if i < len(st.session_state.resume_data['work_experience']) else '2023-01-01', '%Y-%m-%d')).strftime('%Y-%m-%d')
+            job['description'] = st.text_area(f"Job Description {i+1}", st.session_state.resume_data['work_experience'][i]['description'] if i < len(st.session_state.resume_data['work_experience']) else '', height=100)
+            work_experience.append(job)
+        
+        col1, col2 = st.columns(2)
+        if col1.button("Previous"):
+            st.session_state.step = 1
+        if col2.button("Next"):
+            if all(job['title'] and job['company'] and job['description'] for job in work_experience):
+                st.session_state.resume_data['work_experience'] = work_experience
+                st.session_state.step = 3
+            else:
+                st.error("Please fill in all required fields for each job before proceeding.")
+    
+    # Step 3: Education
+    elif st.session_state.step == 3:
+        st.subheader("Step 3: Education")
+        num_edu = st.number_input("Number of education entries", min_value=1, max_value=5, value=len(st.session_state.resume_data['education']) or 1)
+        
+        education = []
+        for i in range(num_edu):
+            st.write(f"Education {i+1}")
+            edu = {}
+            edu['degree'] = st.text_input(f"Degree {i+1}", st.session_state.resume_data['education'][i]['degree'] if i < len(st.session_state.resume_data['education']) else '')
+            edu['field'] = st.text_input(f"Field of Study {i+1}", st.session_state.resume_data['education'][i]['field'] if i < len(st.session_state.resume_data['education']) else '')
+            edu['institution'] = st.text_input(f"Institution {i+1}", st.session_state.resume_data['education'][i]['institution'] if i < len(st.session_state.resume_data['education']) else '')
+            edu['graduation_date'] = st.date_input(f"Graduation Date {i+1}", value=datetime.strptime(st.session_state.resume_data['education'][i]['graduation_date'] if i < len(st.session_state.resume_data['education']) else '2023-01-01', '%Y-%m-%d')).strftime('%Y-%m-%d')
+            education.append(edu)
+        
+        col1, col2 = st.columns(2)
+        if col1.button("Previous"):
+            st.session_state.step = 2
+        if col2.button("Next"):
+            if all(edu['degree'] and edu['field'] and edu['institution'] for edu in education):
+                st.session_state.resume_data['education'] = education
+                st.session_state.step = 4
+            else:
+                st.error("Please fill in all required fields for each education entry before proceeding.")
+    
+    # Step 4: Skills and Generation
+    elif st.session_state.step == 4:
+        st.subheader("Step 4: Skills and Resume Generation")
+        skills_input = st.text_input("Skills (comma-separated)", ', '.join(st.session_state.resume_data['skills']))
+        
+        if st.button("Generate Resume"):
+            if skills_input.strip():
+                st.session_state.resume_data['skills'] = [skill.strip() for skill in skills_input.split(',') if skill.strip()]
+                with st.spinner("Generating AI-enhanced resume content..."):
+                    st.session_state.resume_data = generate_resume_content(st.session_state.resume_data)
+                st.session_state.step = 5
+                st.experimental_rerun()
+            else:
+                st.error("Please enter at least one skill before generating the resume.")
+    
+    # Step 5: Review and Download
+    elif st.session_state.step == 5:
+        st.subheader("Generated Resume")
+        
+        # Display resume content for review
+        st.write("### Personal Information")
+        st.write(f"**Name:** {st.session_state.resume_data['name']}")
+        st.write(f"**Email:** {st.session_state.resume_data['email']}")
+        st.write(f"**Phone:** {st.session_state.resume_data['phone']}")
+        st.write(f"**Location:** {st.session_state.resume_data['location']}")
+        
+        if st.session_state.resume_data['photo']:
+            st.image(st.session_state.resume_data['photo'], caption='Your Photo', width=200)
+        
+        st.write("### Professional Summary")
+        st.write(st.session_state.resume_data['summary'])
+        
+        st.write("### Work Experience")
+        for job in st.session_state.resume_data['work_experience']:
+            st.write(f"**{job['title']} at {job['company']}**")
+            st.write(f"{job['start_date']} - {job['end_date']}")
+            st.write(job['description'])
+        
+        st.write("### Education")
+        for edu in st.session_state.resume_data['education']:
+            st.write(f"**{edu['degree']} in {edu['field']}**")
+            st.write(f"{edu['institution']}, {edu['graduation_date']}")
+        
+        st.write("### Skills")
+        st.write(', '.join(st.session_state.resume_data['skills']))
+        
+        # Calculate and display ATS score
+        ats_score = calculate_ats_score(st.session_state.resume_data)
+        st.write(f"### ATS Compatibility Score: {ats_score}%")
+        
+        # Download options
+        st.write("### Download Options")
+        col1, col2, col3 = st.columns(3)
+        
+        docx_buffer = create_docx(st.session_state.resume_data)
+        col1.download_button(
+            label="Download as DOCX",
+            data=docx_buffer,
+            file_name="resume.docx",
+            mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+        )
+        
+        pdf_buffer = create_pdf(st.session_state.resume_data)
+        col2.download_button(
+            label="Download as PDF",
+            data=pdf_buffer,
+            file_name="resume.pdf",
+            mime="application/pdf"
+        )
+        
+        txt_content = create_txt(st.session_state.resume_data)
+        col3.download_button(
+            label="Download as TXT",
+            data=txt_content,
+            file_name="resume.txt",
+            mime="text/plain"
+        )
+        
+        if st.button("Edit Resume"):
+            st.session_state.step = 1
+        
+        if st.button("Start Over"):
+            st.session_state.step = 1
+            st.session_state.resume_data = {
+                'name': '', 'email': '', 'phone': '', 'location': '',
+                'summary': '', 'work_experience': [], 'education': [], 'skills': [], 'photo': None
+            }
+            st.experimental_rerun()
+
+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 = os.getenv('AI71_API_KEY')
+
+# 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()