Update app.py

app.py

@@ -1,24 +1,18 @@
 import streamlit as st
-import anthropic, openai, base64, cv2, glob, json, math, os, pytz, random, re, requests, textract, time, zipfile
-import plotly.graph_objects as go
-import streamlit.components.v1 as components
+import anthropic
+import openai
+import base64
+import cv2
+import glob
+import os
+import re
+import asyncio
+import edge_tts
 from datetime import datetime
-from audio_recorder_streamlit import audio_recorder
-from bs4 import BeautifulSoup
-from collections import defaultdict, deque
+from collections import defaultdict
 from dotenv import load_dotenv
 from gradio_client import Client
-from huggingface_hub import InferenceClient
-from io import BytesIO
 from PIL import Image
-from PyPDF2 import PdfReader
-from urllib.parse import quote
-from xml.etree import ElementTree as ET
-from openai import OpenAI
-import extra_streamlit_components as stx
-from streamlit.runtime.scriptrunner import get_script_run_ctx
-import asyncio
-import edge_tts
 
 # 🎯 1. Core Configuration & Setup
 st.set_page_config(
@@ -36,8 +30,7 @@ load_dotenv()
 
 # 🔑 2. API Setup & Clients
 openai_api_key = os.getenv('OPENAI_API_KEY', "")
-anthropic_key = os.getenv('ANTHROPIC_API_KEY_3', "")
-xai_key = os.getenv('xai',"")
+anthropic_key = os.getenv('ANTHROPIC_API_KEY', "")
 if 'OPENAI_API_KEY' in st.secrets:
     openai_api_key = st.secrets['OPENAI_API_KEY']
 if 'ANTHROPIC_API_KEY' in st.secrets:
@@ -45,41 +38,29 @@ if 'ANTHROPIC_API_KEY' in st.secrets:
 
 openai.api_key = openai_api_key
 claude_client = anthropic.Anthropic(api_key=anthropic_key)
-openai_client = OpenAI(api_key=openai.api_key, organization=os.getenv('OPENAI_ORG_ID'))
-HF_KEY = os.getenv('HF_KEY')
-API_URL = os.getenv('API_URL')
 
 # 📝 3. Session State Management
-if 'transcript_history' not in st.session_state:
-    st.session_state['transcript_history'] = []
-if 'chat_history' not in st.session_state:
-    st.session_state['chat_history'] = []
-if 'openai_model' not in st.session_state:
-    st.session_state['openai_model'] = "gpt-4o-2024-05-13"
-if 'messages' not in st.session_state:
-    st.session_state['messages'] = []
-if 'last_voice_input' not in st.session_state:
-    st.session_state['last_voice_input'] = ""
-if 'editing_file' not in st.session_state:
-    st.session_state['editing_file'] = None
-if 'edit_new_name' not in st.session_state:
-    st.session_state['edit_new_name'] = ""
-if 'edit_new_content' not in st.session_state:
-    st.session_state['edit_new_content'] = ""
+if 'parsed_papers' not in st.session_state:
+    st.session_state['parsed_papers'] = []
+if 'audio_generated' not in st.session_state:
+    st.session_state['audio_generated'] = {}
+if 'voices' not in st.session_state:
+    st.session_state['voices'] = []
 if 'viewing_prefix' not in st.session_state:
     st.session_state['viewing_prefix'] = None
 if 'should_rerun' not in st.session_state:
     st.session_state['should_rerun'] = False
-if 'old_val' not in st.session_state:
-    st.session_state['old_val'] = None
-if 'audio_generated' not in st.session_state:
-    st.session_state['audio_generated'] = {}
 
 # 🎨 4. Custom CSS
 st.markdown("""
 <style>
-    .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
-    .stMarkdown { font-family: 'Helvetica Neue', sans-serif; }
+    .main { 
+        background: linear-gradient(to right, #1a1a1a, #2d2d2d); 
+        color: #fff; 
+    }
+    .stMarkdown { 
+        font-family: 'Helvetica Neue', sans-serif; 
+    }
     .stButton>button {
         margin-right: 0.5rem;
     }
@@ -153,46 +134,34 @@ def clean_text_for_filename(text: str) -> str:
     return '_'.join(filtered)[:200]
 
 # 📁 6. File Operations
-def generate_filename(prompt, response, file_type="md"):
+def generate_filename(prefix, title, file_type="md"):
     """
-    Generate filename with meaningful terms and short dense clips from prompt & response.
-    The filename should be about 150 chars total, include high-info terms, and a clipped snippet.
+    Generate filename with meaningful terms and prefix.
+    The filename includes a timestamp and a cleaned title.
     """
-    prefix = datetime.now().strftime("%y%m_%H%M") + "_"
-    combined = (prompt + " " + response).strip()
-    info_terms = get_high_info_terms(combined)
-    
-    # Include a short snippet from prompt and response
-    snippet = (prompt[:100] + " " + response[:100]).strip()
-    snippet_cleaned = clean_text_for_filename(snippet)
-    
-    # Combine info terms and snippet
-    name_parts = info_terms + [snippet_cleaned]
-    full_name = '_'.join(name_parts)
-
-    # Trim to ~150 chars
-    if len(full_name) > 150:
-        full_name = full_name[:150]
-    
-    filename = f"{prefix}{full_name}.{file_type}"
+    timestamp = datetime.now().strftime("%y%m_%H%M")
+    title_cleaned = clean_text_for_filename(title)
+    filename = f"{timestamp}_{prefix}_{title_cleaned}.{file_type}"
     return filename
 
-def create_file(prompt, response, file_type="md"):
-    """Create file with intelligent naming"""
-    filename = generate_filename(prompt.strip(), response.strip(), file_type)
+def create_md_file(paper):
+    """Create Markdown file for a paper."""
+    filename = generate_filename("paper", paper['title'], "md")
+    content = f"# {paper['title']}\n\n**Year:** {paper['year'] if paper['year'] else 'Unknown'}\n\n**Summary:**\n{paper['summary']}"
     with open(filename, 'w', encoding='utf-8') as f:
-        f.write(prompt.replace('\n', ' ') + "\n\n" + response)
+        f.write(content)
     return filename
 
 def get_download_link(file):
-    """Generate download link for file"""
-    with open(file, "rb") as f:
-        b64 = base64.b64encode(f.read()).decode()
-    return f'<a href="data:file/zip;base64,{b64}" download="{os.path.basename(file)}">📂 Download {os.path.basename(file)}</a>'
+    """Generate download link for file."""
+    with open(file, "rb") as f_file:
+        b64 = base64.b64encode(f_file.read()).decode()
+    mime_type = "audio/mpeg" if file.endswith(".mp3") else "text/markdown"
+    return f'<a href="data:{mime_type};base64,{b64}" download="{os.path.basename(file)}">📂 Download {os.path.basename(file)}</a>'
 
 # 🔊 7. Audio Processing
 def clean_for_speech(text: str) -> str:
-    """Clean text for speech synthesis"""
+    """Clean text for speech synthesis."""
     text = text.replace("\n", " ")
     text = text.replace("</s>", " ")
     text = text.replace("#", "")
@@ -200,33 +169,20 @@ def clean_for_speech(text: str) -> str:
     text = re.sub(r"\s+", " ", text).strip()
     return text
 
-@st.cache_resource
-def speech_synthesis_html(result):
-    """Create HTML for speech synthesis"""
-    html_code = f"""
-    <html><body>
-    <script>
-    var msg = new SpeechSynthesisUtterance("{result.replace('"', '')}");
-    window.speechSynthesis.speak(msg);
-    </script>
-    </body></html>
-    """
-    components.html(html_code, height=0)
-
 async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0):
-    """Generate audio using Edge TTS"""
+    """Generate audio using Edge TTS."""
     text = clean_for_speech(text)
     if not text.strip():
         return None
     rate_str = f"{rate:+d}%"
     pitch_str = f"{pitch:+d}Hz"
     communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
-    out_fn = generate_filename(text, text, "mp3")
+    out_fn = generate_filename("audio", text[:50], "mp3")
     await communicate.save(out_fn)
     return out_fn
 
 def speak_with_edge_tts(text, voice, rate=0, pitch=0):
-    """Wrapper for edge TTS generation"""
+    """Wrapper for Edge TTS generation."""
     try:
         return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch))
     except Exception as e:
@@ -234,49 +190,45 @@ def speak_with_edge_tts(text, voice, rate=0, pitch=0):
         return None
 
 def play_and_download_audio(file_path):
-    """Play and provide download link for audio"""
+    """Play and provide download link for audio."""
     if file_path and os.path.exists(file_path):
         st.audio(file_path)
-        dl_link = f'<a href="data:audio/mpeg;base64,{base64.b64encode(open(file_path,"rb").read()).decode()}" download="{os.path.basename(file_path)}">Download {os.path.basename(file_path)}</a>'
+        dl_link = get_download_link(file_path)
         st.markdown(dl_link, unsafe_allow_html=True)
 
 # 🎬 8. Media Processing
 def process_image(image_path, user_prompt):
-    """Process image with GPT-4V"""
+    """Process image with GPT-4V."""
     with open(image_path, "rb") as imgf:
         image_data = imgf.read()
     b64img = base64.b64encode(image_data).decode("utf-8")
-    resp = openai_client.chat.completions.create(
+    resp = openai.ChatCompletion.create(
         model=st.session_state["openai_model"],
         messages=[
             {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": [
-                {"type": "text", "text": user_prompt},
-                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64img}"}}
-            ]}
+            {"role": "user", "content": f"{user_prompt} Image data: data:image/png;base64,{b64img}"}
         ],
         temperature=0.0,
     )
     return resp.choices[0].message.content
 
-def process_audio(audio_path):
-    """Process audio with Whisper"""
+def process_audio_file(audio_path):
+    """Process audio with Whisper."""
     with open(audio_path, "rb") as f:
-        transcription = openai_client.audio.transcriptions.create(model="whisper-1", file=f)
-    st.session_state.messages.append({"role": "user", "content": transcription.text})
-    return transcription.text
+        transcription = openai.Audio.transcribe("whisper-1", f)
+    return transcription['text']
 
 def process_video(video_path, seconds_per_frame=1):
-    """Extract frames from video"""
+    """Extract frames from video."""
     vid = cv2.VideoCapture(video_path)
     total = int(vid.get(cv2.CAP_PROP_FRAME_COUNT))
     fps = vid.get(cv2.CAP_PROP_FPS)
-    skip = int(fps*seconds_per_frame)
+    skip = int(fps * seconds_per_frame)
     frames_b64 = []
     for i in range(0, total, skip):
         vid.set(cv2.CAP_PROP_POS_FRAMES, i)
         ret, frame = vid.read()
-        if not ret: 
+        if not ret:
             break
         _, buf = cv2.imencode(".jpg", frame)
         frames_b64.append(base64.b64encode(buf).decode("utf-8"))
@@ -284,75 +236,92 @@ def process_video(video_path, seconds_per_frame=1):
     return frames_b64
 
 def process_video_with_gpt(video_path, prompt):
-    """Analyze video frames with GPT-4V"""
+    """Analyze video frames with GPT-4V."""
     frames = process_video(video_path)
-    resp = openai_client.chat.completions.create(
+    combined_images = " ".join([f"data:image/jpeg;base64,{fr}" for fr in frames])
+    resp = openai.ChatCompletion.create(
         model=st.session_state["openai_model"],
         messages=[
-            {"role":"system","content":"Analyze video frames."},
-            {"role":"user","content":[
-                {"type":"text","text":prompt},
-                *[{"type":"image_url","image_url":{"url":f"data:image/jpeg;base64,{fr}"}} for fr in frames]
-            ]}
+            {"role":"system","content":"Analyze the following video frames."},
+            {"role":"user","content": f"{prompt} Frames: {combined_images}"}
         ]
     )
     return resp.choices[0].message.content
 
 # 🤖 9. AI Model Integration
-
-def save_full_transcript(query, text):
-    """Save full transcript of Arxiv results as a file."""
-    create_file(query, text, "md")
-
-def parse_arxiv_refs(ref_text: str):
+def parse_papers(transcript_text: str):
     """
-    Parse the multi-line references returned by the RAG pipeline.
-    Typical format lines like:
-       1) [Paper Title 2023] This is the summary ...
-       2) [Another Title (2024)] Another summary text ...
-    We'll attempt to find a year with a small regex or fallback.
-    Return list of dicts: { 'title': str, 'summary': str, 'year': int or None }
+    Parse the transcript text into individual papers.
+    Assumes that each paper starts with a number and is enclosed in brackets for the title and year.
+    Example:
+        1) [Paper Title (2023)] This is the summary...
     """
-    lines = ref_text.split('\n')
-    results = []
-    for line in lines:
-        line = line.strip()
-        if not line:
-            continue
-        # Attempt to find [Title ...]
-        title_match = re.search(r"\[([^\]]+)\]", line)
-        if title_match:
-            raw_title = title_match.group(1).strip()
-        else:
-            # If no bracket found, skip or treat entire line as summary
-            raw_title = "No Title"
-
-        # Attempt to find trailing summary after bracket
-        # Example line: " [Paper Title 2024] Paper summary blah blah"
-        # So remove the bracketed portion from the line
-        remainder = line.replace(title_match.group(0), "").strip() if title_match else line
-        summary = remainder
-
-        # Attempt to guess year from the raw title
-        # We look for 4-digit patterns in raw_title or summary
-        year_match = re.search(r'(20\d{2})', raw_title)
-        if not year_match:
-            # fallback: try summary
-            year_match = re.search(r'(20\d{2})', summary)
-        if year_match:
-            year = int(year_match.group(1))
-        else:
-            year = None
-
-        results.append({
-            'title': raw_title,
-            'summary': summary,
-            'year': year
-        })
-        if len(results) >= 20:
-            break
-    return results
+    papers = []
+    # Split based on numbered entries
+    paper_blocks = re.split(r'\d+\)\s*\[', transcript_text)
+    for block in paper_blocks[1:]:  # Skip the first split as it doesn't contain paper info
+        try:
+            title_year, summary = block.split(']', 1)
+            # Extract title and year using regex
+            title_match = re.match(r"(.+?)\s*\((\d{4})\)", title_year)
+            if title_match:
+                title = title_match.group(1).strip()
+                year = int(title_match.group(2))
+            else:
+                title = title_year.strip()
+                year = None
+            summary = summary.strip()
+            papers.append({
+                'title': title,
+                'year': year,
+                'summary': summary
+            })
+        except ValueError:
+            continue  # Skip blocks that don't match the expected format
+    return papers
+
+def save_paper_files(paper, voice):
+    """Generate and save Markdown and MP3 files for a paper."""
+    # Create Markdown file
+    md_filename = create_md_file(paper)
+    
+    # Generate audio for the entire paper
+    audio_text = f"{paper['title']}. {paper['summary']}"
+    audio_filename = speak_with_edge_tts(audio_text, voice)
+    
+    return md_filename, audio_filename
+
+def display_papers(papers, voice):
+    """Display all papers with options to generate audio."""
+    for idx, paper in enumerate(papers):
+        st.markdown(f"### {idx + 1}. {paper['title']} ({paper['year'] if paper['year'] else 'Unknown Year'})")
+        st.markdown(f"**Summary:** {paper['summary']}")
+        
+        # Button to generate and play audio
+        if st.button(f"🔊 Read Aloud - {paper['title']}", key=f"read_aloud_{idx}"):
+            md_file, audio_file = save_paper_files(paper, voice)
+            if audio_file:
+                st.success("Audio generated successfully!")
+                play_and_download_audio(audio_file)
+            else:
+                st.error("Failed to generate audio.")
+        
+        st.write("---")
+
+def cache_parsed_papers(papers):
+    """Cache the parsed papers."""
+    st.session_state['parsed_papers'] = papers
 
+def get_cached_papers():
+    """Retrieve cached papers."""
+    return st.session_state.get('parsed_papers', [])
+
+def save_full_transcript(query, text):
+    """Save full transcript of Arxiv results as a file."""
+    filename = generate_filename("transcript", query, "md")
+    with open(filename, 'w', encoding='utf-8') as f:
+        f.write(text)
+    return filename
 
 def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
                       titles_summary=True, full_audio=False, selected_voice="en-US-AriaNeural"):
@@ -361,123 +330,33 @@ def perform_ai_lookup(q, vocal_summary=True, extended_refs=False,
 
     # 🎯 1) 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",api_name="/update_with_rag_md")[0]
-    r2 = client.predict(q,"mistralai/Mixtral-8x7B-Instruct-v0.1",True,api_name="/ask_llm")
-
+    refs = client.predict(q, 20, "Semantic Search", "mistralai/Mixtral-8x7B-Instruct-v0.1", api_name="/update_with_rag_md")[0]
+    r2 = client.predict(q, "mistralai/Mixtral-8x7B-Instruct-v0.1", True, api_name="/ask_llm")
+    
     # 🎯 2) Combine for final text output
     clean_q = q.replace('\n', ' ')
     result = f"### 🔎 {clean_q}\n\n{r2}\n\n{refs}"
     st.markdown(result)
-
-    # 🎯 3) Generate "all at once" audio if requested
-    if full_audio:
-        complete_text = f"Complete response for query: {clean_q}. {clean_for_speech(r2)} {clean_for_speech(refs)}"
-        audio_file_full = speak_with_edge_tts(complete_text, selected_voice)
-        st.write("### 📚 Full Audio")
-        play_and_download_audio(audio_file_full)
-
-    if vocal_summary:
-        main_text = clean_for_speech(r2)
-        audio_file_main = speak_with_edge_tts(main_text, selected_voice)
-        st.write("### 🎙 Short Audio")
-        play_and_download_audio(audio_file_main)
-
-    if extended_refs:
-        summaries_text = "Extended references: " + refs.replace('"','')
-        summaries_text = clean_for_speech(summaries_text)
-        audio_file_refs = speak_with_edge_tts(summaries_text, selected_voice)
-        st.write("### 📜 Long Refs")
-        play_and_download_audio(audio_file_refs)
-
-    # --------------------------------------
-    # NEW: Parse references, show sorted list
-    # --------------------------------------
-    parsed_refs = parse_arxiv_refs(refs)
-
-    st.write("## Individual Papers (Most Recent First)")
-    for idx, paper in enumerate(parsed_refs):
-        section_key = f"section_{idx}"
-        with st.expander(f"{idx+1}. {paper['title']} - {paper['year'] if paper['year'] else 'Unknown Year'}", expanded=False):
-            st.markdown(f"**Summary:** {paper['summary']}")
-            colA, colB = st.columns(2)
-            with colA:
-                if st.checkbox(f"Generate Audio for Title", key=f"gen_title_{idx}"):
-                    if f"title_audio_{idx}" not in st.session_state['audio_generated']:
-                        text_tts = clean_for_speech(paper['title'])
-                        audio_file_title = speak_with_edge_tts(text_tts, selected_voice)
-                        st.session_state['audio_generated'][f"title_audio_{idx}"] = audio_file_title
-                    play_and_download_audio(st.session_state['audio_generated'].get(f"title_audio_{idx}"))
-            with colB:
-                if st.checkbox(f"Generate Audio for Title + Summary", key=f"gen_summary_{idx}"):
-                    if f"summary_audio_{idx}" not in st.session_state['audio_generated']:
-                        text_tts = clean_for_speech(paper['title'] + ". " + paper['summary'])
-                        audio_file_title_summary = speak_with_edge_tts(text_tts, selected_voice)
-                        st.session_state['audio_generated'][f"summary_audio_{idx}"] = audio_file_title_summary
-                    play_and_download_audio(st.session_state['audio_generated'].get(f"summary_audio_{idx}"))
-            st.write("---")
-
-    # Keep your original block for "Titles Only" if you want:
-    if titles_summary:
-        titles = []
-        for line in refs.split('\n')[:20]:
-            m = re.search(r"\[([^\]]+)\]", line)
-            if m:
-                titles.append(m.group(1))
-        if titles:
-            titles_text = "Titles: " + ", ".join(titles)
-            titles_text = clean_for_speech(titles_text)
-            audio_file_titles = speak_with_edge_tts(titles_text, selected_voice)
-            st.write("### 🔖 Titles (All-In-One)")
-            play_and_download_audio(audio_file_titles)
-
-    elapsed = time.time()-start
+    
+    # 🎯 3) Parse papers from the references
+    parsed_papers = parse_papers(refs)
+    cache_parsed_papers(parsed_papers)
+    
+    # 🎯 4) Display all parsed papers with options
+    st.write("## Individual Papers")
+    display_papers(parsed_papers, selected_voice)
+    
+    elapsed = time.time() - start
     st.write(f"**Total Elapsed:** {elapsed:.2f} s")
-
+    
     # Always create a file with the result
-    create_file(clean_q, result, "md")
-
+    save_full_transcript(clean_q, result)
+    
     return result
 
-def process_with_gpt(text):
-    """Process text with GPT-4"""
-    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
-
 # 📂 10. File Management
 def create_zip_of_files(md_files, mp3_files):
-    """Create zip with intelligent naming"""
+    """Create zip with intelligent naming."""
     md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
     all_files = md_files + mp3_files
     if not all_files:
@@ -491,22 +370,22 @@ def create_zip_of_files(md_files, mp3_files):
                 all_content.append(file.read())
         elif f.endswith('.mp3'):
             all_content.append(os.path.basename(f))
-    
+
     combined_content = " ".join(all_content)
     info_terms = get_high_info_terms(combined_content)
-    
+
     timestamp = datetime.now().strftime("%y%m_%H%M")
     name_text = '_'.join(term.replace(' ', '-') for term in info_terms[:3])
     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 load_files_for_sidebar():
-    """Load and group files for sidebar display"""
+    """Load and group files for sidebar display."""
     md_files = glob.glob("*.md")
     mp3_files = glob.glob("*.mp3")
 
@@ -528,7 +407,7 @@ def load_files_for_sidebar():
     return groups, sorted_prefixes
 
 def extract_keywords_from_md(files):
-    """Extract keywords from markdown files"""
+    """Extract keywords from markdown files."""
     text = ""
     for f in files:
         if f.endswith(".md"):
@@ -537,7 +416,7 @@ def extract_keywords_from_md(files):
     return get_high_info_terms(text)
 
 def display_file_manager_sidebar(groups, sorted_prefixes):
-    """Display file manager in sidebar"""
+    """Display file manager in sidebar."""
     st.sidebar.title("🎵 Audio & Docs Manager")
 
     all_md = []
@@ -564,19 +443,19 @@ def display_file_manager_sidebar(groups, sorted_prefixes):
         if st.button("⬇️ ZipAll"):
             z = create_zip_of_files(all_md, all_mp3)
             if z:
-                st.sidebar.markdown(get_download_link(z),unsafe_allow_html=True)
+                st.sidebar.markdown(get_download_link(z), unsafe_allow_html=True)
 
     for prefix in sorted_prefixes:
         files = groups[prefix]
         kw = extract_keywords_from_md(files)
         keywords_str = " ".join(kw) if kw else "No Keywords"
         with st.sidebar.expander(f"{prefix} Files ({len(files)}) - KW: {keywords_str}", expanded=True):
-            c1,c2 = st.columns(2)
+            c1, c2 = st.columns(2)
             with c1:
-                if st.button("👀ViewGrp", key="view_group_"+prefix):
+                if st.button("👀 View Group", key="view_group_"+prefix):
                     st.session_state.viewing_prefix = prefix
             with c2:
-                if st.button("🗑DelGrp", key="del_group_"+prefix):
+                if st.button("🗑 Delete Group", key="del_group_"+prefix):
                     for f in files:
                         os.remove(f)
                     st.success(f"Deleted group {prefix}!")
@@ -598,12 +477,10 @@ def fetch_voices():
 
 def main():
     st.sidebar.markdown("### 🚲BikeAI🏆 Multi-Agent Research")
-    tab_main = st.radio("Action:",["🎤 Voice","📸 Media","🔍 ArXiv","📝 Editor"],horizontal=True)
-
-    mycomponent = components.declare_component("mycomponent", path="mycomponent")
-    val = mycomponent(my_input_value="Hello")
+    tab_main = st.radio("Action:", ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], horizontal=True)
 
-    if 'voices' not in st.session_state:
+    # Initialize voices if not already done
+    if not st.session_state['voices']:
         st.session_state['voices'] = fetch_voices()
 
     st.sidebar.markdown("### 🎤 Select Voice for Audio Generation")
@@ -613,78 +490,41 @@ def main():
         index=st.session_state['voices'].index("en-US-AriaNeural") if "en-US-AriaNeural" in st.session_state['voices'] else 0
     )
 
-    # Show input in a text box for editing if detected
-    if val:
-        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"])
-        col1, col2 = st.columns(2)
-        with col1:
-            autorun = st.checkbox("⚙ AutoRun", value=True)
-        with col2:
-            full_audio = st.checkbox("📚FullAudio", value=False, 
-                                     help="Generate full audio response")
-
-        input_changed = (val != st.session_state.old_val)
-
-        if autorun and input_changed:
-            st.session_state.old_val = val
-            if run_option == "Arxiv":
-                perform_ai_lookup(
-                    edited_input, 
-                    vocal_summary=True, 
-                    extended_refs=False, 
-                    titles_summary=True, 
-                    full_audio=full_audio,
-                    selected_voice=selected_voice
-                )
-            else:
-                if run_option == "GPT-4o":
-                    process_with_gpt(edited_input)
-                elif run_option == "Claude-3.5":
-                    process_with_claude(edited_input)
-        else:
-            if st.button("▶ Run"):
-                st.session_state.old_val = val
-                if run_option == "Arxiv":
-                    perform_ai_lookup(
-                        edited_input, 
-                        vocal_summary=True, 
-                        extended_refs=False, 
-                        titles_summary=True, 
-                        full_audio=full_audio,
-                        selected_voice=selected_voice
-                    )
-                else:
-                    if run_option == "GPT-4o":
-                        process_with_gpt(edited_input)
-                    elif run_option == "Claude-3.5":
-                        process_with_claude(edited_input)
-
+    # Main Tabs
     if tab_main == "🔍 ArXiv":
         st.subheader("🔍 Query ArXiv")
         q = st.text_input("🔍 Query:").replace('\n', ' ')
 
         st.markdown("### 🎛 Options")
-        vocal_summary = st.checkbox("🎙ShortAudio", value=True)
-        extended_refs = st.checkbox("📜LongRefs", value=False)
-        titles_summary = st.checkbox("🔖TitlesOnly", value=True)
-        full_audio = st.checkbox("📚FullAudio", value=False,
-                                 help="Full audio of results")
-        full_transcript = st.checkbox("🧾FullTranscript", value=False,
-                                      help="Generate a full transcript file")
-
-        if q and st.button("🔍Run"):
-            result = perform_ai_lookup(q, vocal_summary=vocal_summary, extended_refs=extended_refs, 
-                                       titles_summary=titles_summary, full_audio=full_audio, selected_voice=selected_voice)
+        vocal_summary = st.checkbox("🎙 Short Audio", value=True)
+        extended_refs = st.checkbox("📜 Long References", value=False)
+        titles_summary = st.checkbox("🔖 Titles Only", value=True)
+        full_audio = st.checkbox("📚 Full Audio", value=False, help="Generate full audio response")
+        full_transcript = st.checkbox("🧾 Full Transcript", value=False, help="Generate a full transcript file")
+
+        if q and st.button("🔍 Run"):
+            result = perform_ai_lookup(
+                q, 
+                vocal_summary=vocal_summary, 
+                extended_refs=extended_refs, 
+                titles_summary=titles_summary, 
+                full_audio=full_audio, 
+                selected_voice=selected_voice
+            )
             if full_transcript:
                 save_full_transcript(q, result)
 
         st.markdown("### Change Prompt & Re-Run")
         q_new = st.text_input("🔄 Modify Query:").replace('\n', ' ')
         if q_new and st.button("🔄 Re-Run with Modified Query"):
-            result = perform_ai_lookup(q_new, vocal_summary=vocal_summary, extended_refs=extended_refs, 
-                                       titles_summary=titles_summary, full_audio=full_audio, selected_voice=selected_voice)
+            result = perform_ai_lookup(
+                q_new, 
+                vocal_summary=vocal_summary, 
+                extended_refs=extended_refs, 
+                titles_summary=titles_summary, 
+                full_audio=full_audio, 
+                selected_voice=selected_voice
+            )
             if full_transcript:
                 save_full_transcript(q_new, result)
 
@@ -695,13 +535,13 @@ def main():
         if st.button("📨 Send"):
             process_with_gpt(user_text)
         st.subheader("📜 Chat History")
-        t1,t2=st.tabs(["Claude History","GPT-4o History"])
+        t1, t2 = st.tabs(["Claude History", "GPT-4o History"])
         with t1:
-            for c in st.session_state.chat_history:
+            for c in st.session_state.get('chat_history', []):
                 st.write("**You:**", c["user"])
                 st.write("**Claude:**", c["claude"])
         with t2:
-            for m in st.session_state.messages:
+            for m in st.session_state.get('messages', []):
                 with st.chat_message(m["role"]):
                     st.markdown(m["content"])
 
@@ -709,18 +549,18 @@ def main():
         st.header("📸 Images & 🎥 Videos")
         tabs = st.tabs(["🖼 Images", "🎥 Video"])
         with tabs[0]:
-            imgs = glob.glob("*.png")+glob.glob("*.jpg")
+            imgs = glob.glob("*.png") + glob.glob("*.jpg")
             if imgs:
-                c = st.slider("Cols",1,5,3)
-                cols = st.columns(c)
-                for i,f in enumerate(imgs[:20]):
-                    with cols[i%c]:
-                        st.image(Image.open(f),use_container_width=True)
+                cols = st.columns(min(5, len(imgs)))
+                for i, f in enumerate(imgs[:20]):
+                    with cols[i % len(cols)]:
+                        st.image(Image.open(f), use_container_width=True)
                         if st.button(f"👀 Analyze {os.path.basename(f)}", key=f"analyze_{f}"):
-                            a = process_image(f,"Describe this image.")
-                            st.markdown(a)
+                            analysis = process_image(f, "Describe this image.")
+                            st.markdown(analysis)
             else:
                 st.write("No images found.")
+
         with tabs[1]:
             vids = glob.glob("*.mp4")[:20]
             if vids:
@@ -728,23 +568,29 @@ def main():
                     with st.expander(f"🎥 {os.path.basename(v)}"):
                         st.video(v)
                         if st.button(f"Analyze {os.path.basename(v)}", key=f"analyze_{v}"):
-                            a = process_video_with_gpt(v,"Describe video.")
-                            st.markdown(a)
+                            analysis = process_video_with_gpt(v, "Describe video.")
+                            st.markdown(analysis)
             else:
                 st.write("No videos found.")
 
     elif tab_main == "📝 Editor":
-        if getattr(st.session_state,'current_file',None):
-            st.subheader(f"Editing: {st.session_state.current_file}")
-            new_text = st.text_area("✏️ Content:", st.session_state.file_content, height=300)
-            if st.button("💾 Save"):
-                with open(st.session_state.current_file,'w',encoding='utf-8') as f:
-                    f.write(new_text)
-                st.success("Updated!")
-                st.session_state.should_rerun = True
+        st.subheader("📝 Editor")
+        files = glob.glob("*.md")
+        if files:
+            selected_file = st.selectbox("Select a file to edit:", files)
+            if selected_file:
+                with open(selected_file, 'r', encoding='utf-8') as f:
+                    file_content = f.read()
+                new_text = st.text_area("✏️ Content:", file_content, height=300)
+                if st.button("💾 Save"):
+                    with open(selected_file, 'w', encoding='utf-8') as f:
+                        f.write(new_text)
+                    st.success("File updated successfully!")
+                    st.session_state.should_rerun = True
         else:
-            st.write("Select a file from the sidebar to edit.")
+            st.write("No Markdown files available for editing.")
 
+    # File Manager Sidebar
     groups, sorted_prefixes = load_files_for_sidebar()
     display_file_manager_sidebar(groups, sorted_prefixes)
 
@@ -756,7 +602,8 @@ def main():
             ext = os.path.splitext(fname)[1].lower().strip('.')
             st.write(f"### {fname}")
             if ext == "md":
-                content = open(f,'r',encoding='utf-8').read()
+                with open(f, 'r', encoding='utf-8') as file:
+                    content = file.read()
                 st.markdown(content)
             elif ext == "mp3":
                 st.audio(f)
@@ -767,7 +614,55 @@ def main():
 
     if st.session_state.should_rerun:
         st.session_state.should_rerun = False
-        st.rerun()
+        st.experimental_rerun()
 
+def process_with_gpt(text):
+    """Process text with GPT-4."""
+    if not text: 
+        return
+    # Initialize messages if not present
+    if 'messages' not in st.session_state:
+        st.session_state['messages'] = []
+    st.session_state['messages'].append({"role":"user","content":text})
+    with st.chat_message("user"):
+        st.markdown(text)
+    with st.chat_message("assistant"):
+        try:
+            response = openai.ChatCompletion.create(
+                model=st.session_state["openai_model"],
+                messages=st.session_state['messages'],
+                stream=False
+            )
+            ans = response.choices[0].message.content
+            st.write("GPT-4o: " + ans)
+            create_md_file({"title": "User Query", "year": None, "summary": ans})
+            st.session_state['messages'].append({"role":"assistant","content":ans})
+        except Exception as e:
+            st.error(f"Error processing with GPT-4: {e}")
+
+def process_with_claude(text):
+    """Process text with Claude."""
+    if not text: 
+        return
+    # Initialize chat_history if not present
+    if 'chat_history' not in st.session_state:
+        st.session_state['chat_history'] = []
+    with st.chat_message("user"):
+        st.markdown(text)
+    with st.chat_message("assistant"):
+        try:
+            response = claude_client.messages.create(
+                model="claude-3-sonnet-20240229",
+                max_tokens=1000,
+                messages=[{"role":"user","content":text}]
+            )
+            ans = response.content[0].text
+            st.write("Claude-3.5: " + ans)
+            create_md_file({"title": "User Query", "year": None, "summary": ans})
+            st.session_state['chat_history'].append({"user":text,"claude":ans})
+        except Exception as e:
+            st.error(f"Error processing with Claude: {e}")
+
+# Run the application
 if __name__=="__main__":
     main()