Update backup13.app.py

backup13.app.py

@@ -37,8 +37,8 @@ load_dotenv()
 
 # Add available English voices for Edge TTS
 EDGE_TTS_VOICES = [
-    "en-US-AriaNeural",  # Default voice
-    "en-US-GuyNeural", 
+    "en-US-AriaNeural",
+    "en-US-GuyNeural",
     "en-US-JennyNeural",
     "en-GB-SoniaNeural",
     "en-GB-RyanNeural",
@@ -49,6 +49,16 @@ EDGE_TTS_VOICES = [
 ]
 
 # Initialize session state variables
+if 'marquee_settings' not in st.session_state:
+    st.session_state['marquee_settings'] = {
+        "background": "#1E1E1E",
+        "color": "#FFFFFF",
+        "font-size": "14px",
+        "animationDuration": "10s",
+        "width": "100%",
+        "lineHeight": "35px"
+    }
+
 if 'tts_voice' not in st.session_state:
     st.session_state['tts_voice'] = EDGE_TTS_VOICES[0]
 if 'audio_format' not in st.session_state:
@@ -102,26 +112,55 @@ FILE_EMOJIS = {
     "wav": "🔊"
 }
 
-# Marquee Functions
+def get_central_time():
+    """Get current time in US Central timezone"""
+    central = pytz.timezone('US/Central')
+    return datetime.now(central)
+
+def format_timestamp_prefix():
+    """Generate timestamp prefix in format MM_dd_yy_hh_mm_AM/PM"""
+    ct = get_central_time()
+    return ct.strftime("%m_%d_%y_%I_%M_%p")
+
+def initialize_marquee_settings():
+    """Initialize marquee settings in session state"""
+    if 'marquee_settings' not in st.session_state:
+        st.session_state['marquee_settings'] = {
+            "background": "#1E1E1E",
+            "color": "#FFFFFF",
+            "font-size": "14px",
+            "animationDuration": "10s",
+            "width": "100%",
+            "lineHeight": "35px"
+        }
+
 def get_marquee_settings():
-    """Get global marquee settings from sidebar controls"""
+    """Get or update marquee settings from session state"""
+    initialize_marquee_settings()
+    return st.session_state['marquee_settings']
+
+def update_marquee_settings_ui():
+    """Update marquee settings via UI controls"""
+    initialize_marquee_settings()
     st.sidebar.markdown("### 🎯 Marquee Settings")
     cols = st.sidebar.columns(2)
     with cols[0]:
-        bg_color = st.color_picker("🎨 Background", "#1E1E1E", key="bg_color_picker")
-        text_color = st.color_picker("✍️ Text", "#FFFFFF", key="text_color_picker")
+        bg_color = st.color_picker("🎨 Background", 
+                                  st.session_state['marquee_settings']["background"], 
+                                  key="bg_color_picker")
+        text_color = st.color_picker("✍️ Text", 
+                                    st.session_state['marquee_settings']["color"], 
+                                    key="text_color_picker")
     with cols[1]:
         font_size = st.slider("📏 Size", 10, 24, 14, key="font_size_slider")
         duration = st.slider("⏱️ Speed", 1, 20, 10, key="duration_slider")
-    
-    return {
+
+    st.session_state['marquee_settings'].update({
         "background": bg_color,
         "color": text_color,
         "font-size": f"{font_size}px",
-        "animationDuration": f"{duration}s",
-        "width": "100%",
-        "lineHeight": "35px"
-    }
+        "animationDuration": f"{duration}s"
+    })
 
 def display_marquee(text, settings, key_suffix=""):
     """Display marquee with given text and settings"""
@@ -133,13 +172,6 @@ def display_marquee(text, settings, key_suffix=""):
     )
     st.write("")
 
-def process_paper_content(paper):
-    """Process paper content for marquee and audio"""
-    marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:100]} | 📝 {paper['summary'][:100]}"
-    audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
-    return marquee_text, audio_text
-
-# Text Processing Functions
 def get_high_info_terms(text: str, top_n=10) -> list:
     stop_words = set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with'])
     words = re.findall(r'\b\w+(?:-\w+)*\b', text.lower())
@@ -157,17 +189,8 @@ def clean_text_for_filename(text: str) -> str:
     filtered = [w for w in words if len(w) > 3 and w not in stop_short]
     return '_'.join(filtered)[:200]
 
-def clean_for_speech(text: str) -> str:
-    text = text.replace("\n", " ")
-    text = text.replace("</s>", " ")
-    text = text.replace("#", "")
-    text = re.sub(r"\(https?:\/\/[^\)]+\)", "", text)
-    text = re.sub(r"\s+", " ", text).strip()
-    return text
-
-# File Operations
 def generate_filename(prompt, response, file_type="md"):
-    prefix = datetime.now().strftime("%y%m_%H%M") + "_"
+    prefix = format_timestamp_prefix() + "_"
     combined = (prompt + " " + response).strip()
     info_terms = get_high_info_terms(combined, top_n=10)
     snippet = (prompt[:100] + " " + response[:100]).strip()
@@ -198,7 +221,14 @@ def get_download_link(file, file_type="zip"):
     else:
         return f'<a href="data:application/octet-stream;base64,{b64}" download="{os.path.basename(file)}">Download {os.path.basename(file)}</a>'
 
-# Audio Processing
+def clean_for_speech(text: str) -> str:
+    text = text.replace("\n", " ")
+    text = text.replace("</s>", " ")
+    text = text.replace("#", "")
+    text = re.sub(r"\(https?:\/\/[^\)]+\)", "", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
 async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
     text = clean_for_speech(text)
     if not text.strip():
@@ -219,7 +249,74 @@ def play_and_download_audio(file_path, file_type="mp3"):
         dl_link = get_download_link(file_path, file_type=file_type)
         st.markdown(dl_link, unsafe_allow_html=True)
 
-# Paper Processing Functions
+def save_qa_with_audio(question, answer, voice=None):
+    """Save Q&A to markdown and generate audio"""
+    if not voice:
+        voice = st.session_state['tts_voice']
+    
+    # Create markdown file
+    combined_text = f"# Question\n{question}\n\n# Answer\n{answer}"
+    md_file = create_file(question, answer, "md")
+    
+    # Generate audio file
+    audio_text = f"Question: {question}\n\nAnswer: {answer}"
+    audio_file = speak_with_edge_tts(
+        audio_text,
+        voice=voice,
+        file_format=st.session_state['audio_format']
+    )
+    
+    return md_file, audio_file
+
+def process_paper_content(paper):
+    marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:100]} | 📝 {paper['summary'][:100]}"
+    audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
+    return marquee_text, audio_text
+
+def create_paper_audio_files(papers, input_question):
+    for paper in papers:
+        try:
+            marquee_text, audio_text = process_paper_content(paper)
+            
+            audio_text = clean_for_speech(audio_text)
+            file_format = st.session_state['audio_format']
+            audio_file = speak_with_edge_tts(audio_text, 
+                                           voice=st.session_state['tts_voice'], 
+                                           file_format=file_format)
+            paper['full_audio'] = audio_file
+            
+            st.write(f"### {FILE_EMOJIS.get(file_format, '')} {os.path.basename(audio_file)}")
+            play_and_download_audio(audio_file, file_type=file_format)
+            paper['marquee_text'] = marquee_text
+            
+        except Exception as e:
+            st.warning(f"Error processing paper {paper['title']}: {str(e)}")
+paper['full_audio'] = None
+            paper['marquee_text'] = None
+
+def display_papers(papers, marquee_settings):
+    st.write("## Research Papers")
+    
+    papercount = 0
+    for paper in papers:
+        papercount += 1
+        if papercount <= 20:
+            if paper.get('marquee_text'):
+                display_marquee(paper['marquee_text'], 
+                              marquee_settings,
+                              key_suffix=f"paper_{papercount}")
+            
+            with st.expander(f"{papercount}. 📄 {paper['title']}", expanded=True):
+                st.markdown(f"**{paper['date']} | {paper['title']} | ⬇️**")
+                st.markdown(f"*{paper['authors']}*")
+                st.markdown(paper['summary'])
+                
+                if paper.get('full_audio'):
+                    st.write("📚 Paper Audio")
+                    file_ext = os.path.splitext(paper['full_audio'])[1].lower().strip('.')
+                    if file_ext in ['mp3', 'wav']:
+                        st.audio(paper['full_audio'])
+
 def parse_arxiv_refs(ref_text: str):
     if not ref_text:
         return []
@@ -269,58 +366,10 @@ def parse_arxiv_refs(ref_text: str):
     
     return results[:20]
 
-def create_paper_audio_files(papers, input_question):
-    for paper in papers:
-        try:
-            marquee_text, audio_text = process_paper_content(paper)
-            
-            audio_text = clean_for_speech(audio_text)
-            file_format = st.session_state['audio_format']
-            audio_file = speak_with_edge_tts(audio_text, 
-                                           voice=st.session_state['tts_voice'], 
-                                           file_format=file_format)
-            paper['full_audio'] = audio_file
-            
-            st.write(f"### {FILE_EMOJIS.get(file_format, '')} {os.path.basename(audio_file)}")
-            play_and_download_audio(audio_file, file_type=file_format)
-            paper['marquee_text'] = marquee_text
-            
-        except Exception as e:
-            st.warning(f"Error processing paper {paper['title']}: {str(e)}")
-            paper['full_audio'] = None
-            paper['marquee_text'] = None
-
-def display_papers(papers, marquee_settings):
-    """Display papers with their audio controls and marquee summaries"""
-    st.write("## Research Papers")
-    
-    papercount = 0
-    for paper in papers:
-        papercount += 1
-        if papercount <= 20:
-            # Display marquee if text exists
-            if paper.get('marquee_text'):
-                display_marquee(paper['marquee_text'], 
-                              marquee_settings,
-                              key_suffix=f"paper_{papercount}")
-            
-            with st.expander(f"{papercount}. 📄 {paper['title']}", expanded=True):
-                st.markdown(f"**{paper['date']} | {paper['title']} | ⬇️**")
-                st.markdown(f"*{paper['authors']}*")
-                st.markdown(paper['summary'])
-                
-                if paper.get('full_audio'):
-                    st.write("📚 Paper Audio")
-                    file_ext = os.path.splitext(paper['full_audio'])[1].lower().strip('.')
-                    if file_ext in ['mp3', 'wav']:
-                        st.audio(paper['full_audio'])
-
 def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
-                     titles_summary=True, full_audio=False, marquee_settings=None):
-    """Perform Arxiv search with audio generation per paper."""
+                     titles_summary=True, full_audio=False):
     start = time.time()
 
-    # Query the HF RAG pipeline
     client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
     refs = client.predict(q, 20, "Semantic Search", 
                          "mistralai/Mixtral-8x7B-Instruct-v0.1",
@@ -328,124 +377,76 @@ def perform_ai_lookup(q, vocal_summary=True, extended_refs=False,
     r2 = client.predict(q, "mistralai/Mixtral-8x7B-Instruct-v0.1", 
                        True, api_name="/ask_llm")
 
-    # Combine for final text output
     result = f"### 🔎 {q}\n\n{r2}\n\n{refs}"
     st.markdown(result)
 
-    # Parse and process papers
+    md_file, audio_file = save_qa_with_audio(q, result)
+    
+    st.subheader("📝 Main Response Audio")
+    play_and_download_audio(audio_file, st.session_state['audio_format'])
+
     papers = parse_arxiv_refs(refs)
     if papers:
         create_paper_audio_files(papers, input_question=q)
-        if marquee_settings:
-            display_papers(papers, marquee_settings)
-        else:
-            display_papers(papers, get_marquee_settings())
+        display_papers(papers, get_marquee_settings())
     else:
         st.warning("No papers found in the response.")
 
     elapsed = time.time()-start
     st.write(f"**Total Elapsed:** {elapsed:.2f} s")
-
-    # Save full transcript
-    create_file(q, result, "md")
     return result
 
-def process_with_gpt(text):
-    """Process text with GPT-4"""
-    if not text: 
+def process_voice_input(text):
+    if not text:
         return
-    st.session_state.messages.append({"role":"user","content":text})
-    with st.chat_message("user"):
-        st.markdown(text)
-    with st.chat_message("assistant"):
-        c = openai_client.chat.completions.create(
-            model=st.session_state["openai_model"],
-            messages=st.session_state.messages,
-            stream=False
-        )
-        ans = c.choices[0].message.content
-        st.write("GPT-4o: " + ans)
-        create_file(text, ans, "md")
-        st.session_state.messages.append({"role":"assistant","content":ans})
-    return ans
-
-def process_with_claude(text):
-    """Process text with Claude"""
-    if not text: 
-        return
-    with st.chat_message("user"):
-        st.markdown(text)
-    with st.chat_message("assistant"):
-        r = claude_client.messages.create(
-            model="claude-3-sonnet-20240229",
-            max_tokens=1000,
-            messages=[{"role":"user","content":text}]
-        )
-        ans = r.content[0].text
-        st.write("Claude-3.5: " + ans)
-        create_file(text, ans, "md")
-        st.session_state.chat_history.append({"user":text,"claude":ans})
-    return ans
+        
+    st.subheader("🔍 Search Results")
+    result = perform_ai_lookup(
+        text, 
+        vocal_summary=True,
+        extended_refs=False,
+        titles_summary=True,
+        full_audio=True
+    )
+    
+    md_file, audio_file = save_qa_with_audio(text, result)
+    
+    st.subheader("📝 Generated Files")
+    st.write(f"Markdown: {md_file}")
+    st.write(f"Audio: {audio_file}")
+    play_and_download_audio(audio_file, st.session_state['audio_format'])
 
 def load_files_for_sidebar():
-    """Load and group files for sidebar display based on first 9 characters of filename"""
     md_files = glob.glob("*.md")
     mp3_files = glob.glob("*.mp3")
     wav_files = glob.glob("*.wav")
-
+    
     md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
     all_files = md_files + mp3_files + wav_files
 
     groups = defaultdict(list)
+    prefix_length = len("MM_dd_yy_hh_mm_AP")
+    
     for f in all_files:
         basename = os.path.basename(f)
-        group_name = basename[:9] if len(basename) >= 9 else 'Other'
-        groups[group_name].append(f)
-
+        if len(basename) >= prefix_length and '_' in basename:
+            group_name = basename[:prefix_length]
+            groups[group_name].append(f)
+        else:
+            groups['Other'].append(f)
+            
     sorted_groups = sorted(groups.items(), 
-                         key=lambda x: max(os.path.getmtime(f) for f in x[1]), 
+                         key=lambda x: x[0] if x[0] != 'Other' else '', 
                          reverse=True)
     return sorted_groups
 
-def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
-    """Create zip with intelligent naming based on high-info terms"""
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files + wav_files
-    if not all_files:
-        return None
-
-    all_content = []
-    for f in all_files:
-        if f.endswith('.md'):
-            with open(f, 'r', encoding='utf-8') as file:
-                all_content.append(file.read())
-        elif f.endswith('.mp3') or f.endswith('.wav'):
-            basename = os.path.splitext(os.path.basename(f))[0]
-            words = basename.replace('_', ' ')
-            all_content.append(words)
-    
-    all_content.append(input_question)
-    combined_content = " ".join(all_content)
-    info_terms = get_high_info_terms(combined_content, top_n=10)
-    
-    timestamp = datetime.now().strftime("%y%m_%H%M")
-    name_text = '_'.join(term.replace(' ', '-') for term in info_terms[:10])
-    zip_name = f"{timestamp}_{name_text}.zip"
-    
-    with zipfile.ZipFile(zip_name, 'w') as z:
-        for f in all_files:
-            z.write(f)
-    
-    return zip_name
-
 def display_file_manager_sidebar(groups_sorted):
-    """Display file manager in sidebar with timestamp-based groups"""
     st.sidebar.title("🎵 Audio & Docs Manager")
 
     all_md = []
     all_mp3 = []
     all_wav = []
-    for group_name, files in groups_sorted:
+    for _, files in groups_sorted:
         for f in files:
             if f.endswith(".md"):
                 all_md.append(f)
@@ -454,55 +455,91 @@ def display_file_manager_sidebar(groups_sorted):
             elif f.endswith(".wav"):
                 all_wav.append(f)
 
-    top_bar = st.sidebar.columns(4)
-    with top_bar[0]:
-        if st.button("🗑 DelAllMD"):
+    col1, col2, col3, col4 = st.sidebar.columns(4)
+    with col1:
+        if st.button("🗑 DelMD"):
             for f in all_md:
                 os.remove(f)
             st.session_state.should_rerun = True
-    with top_bar[1]:
-        if st.button("🗑 DelAllMP3"):
+    with col2:
+        if st.button("🗑 DelMP3"):
             for f in all_mp3:
                 os.remove(f)
             st.session_state.should_rerun = True
-    with top_bar[2]:
-        if st.button("🗑 DelAllWAV"):
+    with col3:
+        if st.button("🗑 DelWAV"):
             for f in all_wav:
                 os.remove(f)
             st.session_state.should_rerun = True
-    with top_bar[3]:
+    with col4:
         if st.button("⬇️ ZipAll"):
-            zip_name = create_zip_of_files(all_md, all_mp3, all_wav, 
-                                         input_question=st.session_state.get('last_query', ''))
+            zip_name = create_zip_of_files(all_md, all_mp3, all_wav, st.session_state.get('last_query', ''))
             if zip_name:
-                st.sidebar.markdown(get_download_link(zip_name, file_type="zip"), 
-                                  unsafe_allow_html=True)
+                st.sidebar.markdown(get_download_link(zip_name, "zip"), unsafe_allow_html=True)
 
     for group_name, files in groups_sorted:
-        timestamp_dt = datetime.strptime(group_name, "%y%m_%H%M") if len(group_name) == 9 else None
-        group_label = timestamp_dt.strftime("%Y-%m-%d %H:%M") if timestamp_dt else group_name
-        
+        if group_name == 'Other':
+            group_label = 'Other Files'
+        else:
+            try:
+                timestamp_dt = datetime.strptime(group_name, "%m_%d_%y_%I_%M_%p")
+                group_label = timestamp_dt.strftime("%b %d, %Y %I:%M %p")
+            except ValueError:
+                group_label = group_name
+
         with st.sidebar.expander(f"📁 {group_label} ({len(files)})", expanded=True):
             c1, c2 = st.columns(2)
             with c1:
-                if st.button("👀ViewGrp", key="view_group_"+group_name):
+                if st.button("👀 View", key=f"view_group_{group_name}"):
                     st.session_state.viewing_prefix = group_name
             with c2:
-                if st.button("🗑DelGrp", key="del_group_"+group_name):
+                if st.button("🗑 Del", key=f"del_group_{group_name}"):
                     for f in files:
                         os.remove(f)
-                    st.success(f"Deleted group {group_name}!")
+                    st.success(f"Deleted group {group_label}!")
                     st.session_state.should_rerun = True
-
+                    
             for f in files:
                 fname = os.path.basename(f)
                 ext = os.path.splitext(fname)[1].lower()
                 emoji = FILE_EMOJIS.get(ext.strip('.'), '')
-                ctime = datetime.fromtimestamp(os.path.getmtime(f)).strftime("%H:%M:%S")
+                mtime = os.path.getmtime(f)
+                ctime = datetime.fromtimestamp(mtime).strftime("%I:%M:%S %p")
                 st.write(f"{emoji} **{fname}** - {ctime}")
 
+def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
+    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
+    all_files = md_files + mp3_files + wav_files
+    if not all_files:
+        return None
+
+    all_content = []
+    for f in all_files:
+        if f.endswith('.md'):
+            with open(f, 'r', encoding='utf-8') as file:
+                all_content.append(file.read())
+        elif f.endswith('.mp3') or f.endswith('.wav'):
+            basename = os.path.splitext(os.path.basename(f))[0]
+            words = basename.replace('_', ' ')
+            all_content.append(words)
+    
+    all_content.append(input_question)
+    combined_content = " ".join(all_content)
+    info_terms = get_high_info_terms(combined_content, top_n=10)
+    
+    timestamp = format_timestamp_prefix()
+    name_text = '_'.join(term.replace(' ', '-') for term in info_terms[:10])
+    zip_name = f"{timestamp}_{name_text}.zip"
+    
+    with zipfile.ZipFile(zip_name, 'w') as z:
+        for f in all_files:
+            z.write(f)
+    
+    return zip_name
+
 def main():
-    # Get marquee settings first
+    # Update marquee settings UI first
+    update_marquee_settings_ui()
     marquee_settings = get_marquee_settings()
     
     # Initial welcome marquee
@@ -556,7 +593,7 @@ def main():
         val_stripped = val.replace('\\n', ' ')
         edited_input = st.text_area("✏️ Edit Input:", value=val_stripped, height=100)
         
-        run_option = st.selectbox("Model:", ["Arxiv", "GPT-4o", "Claude-3.5"])
+        run_option = st.selectbox("Model:", ["Arxiv"])
         col1, col2 = st.columns(2)
         with col1:
             autorun = st.checkbox("⚙ AutoRun", value=True)
@@ -568,30 +605,15 @@ def main():
         if autorun and input_changed:
             st.session_state.old_val = val
             st.session_state.last_query = edited_input
-            if run_option == "Arxiv":
-                perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                titles_summary=True, full_audio=full_audio,
-                                marquee_settings=marquee_settings)
-            else:
-                if run_option == "GPT-4o":
-                    process_with_gpt(edited_input)
-                elif run_option == "Claude-3.5":
-                    process_with_claude(edited_input)
+            result = perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
+                                    titles_summary=True, full_audio=full_audio)
         else:
             if st.button("▶ Run"):
                 st.session_state.old_val = val
                 st.session_state.last_query = edited_input
-                if run_option == "Arxiv":
-                    perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                    titles_summary=True, full_audio=full_audio,
-                                    marquee_settings=marquee_settings)
-                else:
-                    if run_option == "GPT-4o":
-                        process_with_gpt(edited_input)
-                    elif run_option == "Claude-3.5":
-                        process_with_claude(edited_input)
+                result = perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
+                                        titles_summary=True, full_audio=full_audio)
     
-    # ArXiv Tab
     if tab_main == "🔍 ArXiv":
         st.subheader("🔍 Query ArXiv")
         q = st.text_input("🔍 Query:")
@@ -606,32 +628,23 @@ def main():
         if q and st.button("🔍Run"):
             st.session_state.last_query = q
             result = perform_ai_lookup(q, vocal_summary=vocal_summary, extended_refs=extended_refs, 
-                                     titles_summary=titles_summary, full_audio=full_audio,
-                                     marquee_settings=marquee_settings)
+                                     titles_summary=titles_summary, full_audio=full_audio)
             if full_transcript:
                 create_file(q, result, "md")
 
-    # Voice Tab
     elif tab_main == "🎤 Voice":
         st.subheader("🎤 Voice Input")
         user_text = st.text_area("💬 Message:", height=100)
         user_text = user_text.strip().replace('\n', ' ')
 
         if st.button("📨 Send"):
-            process_with_gpt(user_text)
+            process_voice_input(user_text)
             
         st.subheader("📜 Chat History")
-        t1, t2 = st.tabs(["Claude History", "GPT-4o History"])
-        with t1:
-            for c in st.session_state.chat_history:
-                st.write("**You:**", c["user"])
-                st.write("**Claude:**", c["claude"])
-        with t2:
-            for m in st.session_state.messages:
-                with st.chat_message(m["role"]):
-                    st.markdown(m["content"])
-
-    # Media Tab
+        for c in st.session_state.chat_history:
+st.write("**You:**", c["user"])
+            st.write("**Response:**", c["claude"])
+
     elif tab_main == "📸 Media":
         st.header("📸 Images & 🎥 Videos")
         tabs = st.tabs(["🖼 Images", "🎥 Video"])
@@ -681,7 +694,6 @@ def main():
             else:
                 st.write("No videos found.")
 
-    # Editor Tab
     elif tab_main == "📝 Editor":
         if st.session_state.editing_file:
             st.subheader(f"Editing: {st.session_state.editing_file}")
@@ -720,7 +732,6 @@ def main():
             st.session_state.viewing_prefix = None
             st.session_state['marquee_content'] = "🚀 Welcome to TalkingAIResearcher | 🤖 Your Research Assistant"
 
-    # Add custom CSS
     st.markdown("""
     <style>
         .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
@@ -729,10 +740,9 @@ def main():
     </style>
     """, unsafe_allow_html=True)
 
-    # Handle rerun if needed
     if st.session_state.should_rerun:
         st.session_state.should_rerun = False
         st.rerun()
 
 if __name__ == "__main__":
-    main()
+    main()