Update app.py

app.py

@@ -2,36 +2,12 @@ import streamlit as st
 import anthropic
 import openai
 import base64
-import cv2
-import glob
-import json
-import math
 import os
-import pytz
-import random
 import re
-import requests
-import textract
-import time
-import zipfile
-import plotly.graph_objects as go
-import streamlit.components.v1 as components
+import asyncio
 from datetime import datetime
-from audio_recorder_streamlit import audio_recorder
-from bs4 import BeautifulSoup
-from collections import defaultdict, deque
-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
+from collections import defaultdict
 import edge_tts
 
 # 🎯 1. Core Configuration & Setup
@@ -46,12 +22,22 @@ st.set_page_config(
         'About': "🚲BikeAI🏆 Claude/GPT Research AI"
     }
 )
-load_dotenv()
+st.markdown("""
+    <style>
+        .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
+        .stMarkdown { font-family: 'Helvetica Neue', sans-serif; }
+        .stButton>button {
+            margin-right: 0.5rem;
+        }
+    </style>
+    """, unsafe_allow_html=True)
 
 # 🔑 2. API Setup & Clients
+from dotenv import load_dotenv
+load_dotenv()
+
 openai_api_key = os.getenv('OPENAI_API_KEY', "")
 anthropic_key = os.getenv('ANTHROPIC_API_KEY_3', "")
-xai_key = os.getenv('xai',"")
 if 'OPENAI_API_KEY' in st.secrets:
     openai_api_key = st.secrets['OPENAI_API_KEY']
 if 'ANTHROPIC_API_KEY' in st.secrets:
@@ -59,9 +45,7 @@ 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')
+openai_client = openai  # Using OpenAI directly
 
 # 📝 3. Session State Management
 if 'transcript_history' not in st.session_state:
@@ -69,17 +53,9 @@ if 'transcript_history' not in st.session_state:
 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"
+    st.session_state['openai_model'] = "gpt-4"  # Update as needed
 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 'viewing_prefix' not in st.session_state:
     st.session_state['viewing_prefix'] = None
 if 'should_rerun' not in st.session_state:
@@ -87,23 +63,7 @@ if 'should_rerun' not in st.session_state:
 if 'old_val' not in st.session_state:
     st.session_state['old_val'] = None
 
-# 🎨 4. Custom CSS
-st.markdown("""
-<style>
-    .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
-    .stMarkdown { font-family: 'Helvetica Neue', sans-serif; }
-    .stButton>button {
-        margin-right: 0.5rem;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-FILE_EMOJIS = {
-    "md": "📝",
-    "mp3": "🎵",
-}
-
-# 🧠 5. High-Information Content Extraction
+# 🧠 4. High-Information Content Extraction
 def get_high_info_terms(text: str) -> list:
     """Extract high-information terms from text, including key phrases."""
     stop_words = set([
@@ -164,7 +124,7 @@ 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]
 
-# 📁 6. File Operations
+# 📁 5. File Operations
 def generate_filename(prompt, response, file_type="md"):
     """
     Generate filename with meaningful terms and short dense clips from prompt & response.
@@ -202,7 +162,7 @@ def get_download_link(file):
         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>'
 
-# 🔊 7. Audio Processing
+# 🔊 6. Audio Processing
 def clean_for_speech(text: str) -> str:
     """Clean text for speech synthesis"""
     text = text.replace("\n", " ")
@@ -212,20 +172,7 @@ 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):
+async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0, out_fn="temp.mp3"):
     """Generate audio using Edge TTS (async)"""
     text = clean_for_speech(text)
     if not text.strip():
@@ -233,13 +180,12 @@ async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=
     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")
     await communicate.save(out_fn)
     return out_fn
 
-def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0):
-    """Wrapper for edge TTS generation (sync)"""
-    return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch))
+def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0, out_fn="temp.mp3"):
+    """Wrapper for Edge TTS generation (sync)"""
+    return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch, out_fn))
 
 def play_and_download_audio(file_path):
     """Play and provide a download link for audio"""
@@ -249,10 +195,7 @@ def play_and_download_audio(file_path):
         st.markdown(dl_link, unsafe_allow_html=True)
 
 def auto_play_audio(file_path):
-    """
-    Reads MP3 file as base64, displays an <audio> tag with autoplay + controls + download link.
-    Note: Some browsers block audio autoplay if there's no user interaction.
-    """
+    """Embeds an <audio> tag with autoplay + controls + a download link."""
     if not file_path or not os.path.exists(file_path):
         return
     with open(file_path, "rb") as f:
@@ -271,45 +214,44 @@ def auto_play_audio(file_path):
 
 def generate_audio_filename(query, title, summary):
     """
-    Example specialized MP3 filename: prefix + query + short snippet of title/summary
+    Generate a specialized MP3 filename using query + title + summary.
+    Example: "2310_1205_query_title_summary.mp3"
     """
     combined = (query + " " + title + " " + summary).strip().lower()
-    combined = re.sub(r'[^\w\s-]', '', combined)  # remove special chars
-    combined = "_".join(combined.split())[:80]    # limit length
+    combined = re.sub(r'[^\w\s-]', '', combined)  # Remove special characters
+    combined = "_".join(combined.split())[:80]    # Limit length
     prefix = datetime.now().strftime("%y%m_%H%M")
     return f"{prefix}_{combined}.mp3"
 
-# 🎬 8. Media Processing
+# 🎬 7. Media Processing
 def process_image(image_path, user_prompt):
-    """Process image with GPT-4V (placeholder logic)"""
+    """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_client.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": [
+                {"type": "text", "text": user_prompt},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64img}"}}
+            ]}
         ],
         temperature=0.0,
     )
     return resp.choices[0].message.content
 
-def process_audio(audio_path):
-    """Process audio with Whisper (placeholder logic)"""
+def process_audio_with_whisper(audio_path):
+    """Process audio with Whisper"""
     with open(audio_path, "rb") as f:
-        transcription = openai_client.audio.transcriptions.create(model="whisper-1", file=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
 
 def process_video(video_path, seconds_per_frame=1):
-    """Extract frames from video (placeholder logic)"""
+    """Extract frames from video"""
+    import cv2
     vid = cv2.VideoCapture(video_path)
     total = int(vid.get(cv2.CAP_PROP_FRAME_COUNT))
     fps = vid.get(cv2.CAP_PROP_FPS)
@@ -326,145 +268,25 @@ 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 (placeholder logic)"""
+    """Analyze video frames with GPT-4V"""
     frames = process_video(video_path)
-    resp = openai_client.chat.completions.create(
+    resp = openai_client.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": "user", "content": [
+                {"type": "text", "text": prompt},
+                *[{"type":"image_url","image_url":{"url":f"data:image/jpeg;base64,{fr}"}} for fr in frames]
+            ]}
         ]
     )
     return resp.choices[0].message.content
 
-# 🤖 9. AI Model Integration
-
+# 🤖 8. AI Model Integration
 def save_full_transcript(query, text):
     """Save full transcript of Arxiv results as a file."""
     create_file(query, text, "md")
 
-# ---------------------------------------------------
-# NEW: Extremely simple "parse_arxiv_refs" logic
-# that reads each non-empty line, up to 20 lines.
-# Extract bracketed title if present, year if present.
-# The entire line is the "summary" for display + TTS.
-# ---------------------------------------------------
-def parse_arxiv_refs(ref_text: str):
-    lines = ref_text.split('\n')
-    # remove empty lines
-    lines = [ln.strip() for ln in lines if ln.strip()]
-    # limit to 20
-    lines = lines[:20]
-
-    refs = []
-    for ln in lines:
-        # bracketed title if found
-        bracket_match = re.search(r"\[([^\]]+)\]", ln)
-        title = bracket_match.group(1) if bracket_match else "No Title"
-        # find a year 20xx if present
-        year_match = re.search(r"(20\d{2})", ln)
-        year = int(year_match.group(1)) if year_match else None
-        
-        refs.append({
-            "line": ln,      # the entire raw line for display
-            "title": title,  # bracketed content or "No Title"
-            "year": year     # e.g. 2023, 2024, or None
-        })
-    return refs
-
-def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
-                      titles_summary=True, full_audio=False):
-    """
-    1) Query the RAG pipeline
-    2) Display results
-    3) Also parse references into lines, up to 20
-    4) Show each reference with full content
-    5) If year in [2023, 2024], auto-generate TTS
-    """
-    start = time.time()
-
-    # 1) Query HF RAG pipeline
-    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-    # 20 references
-    refs = client.predict(q, 20, "Semantic Search", "mistralai/Mixtral-8x7B-Instruct-v0.1",
-                          api_name="/update_with_rag_md")[0]
-    # Main summary
-    r2 = client.predict(q, "mistralai/Mixtral-8x7B-Instruct-v0.1", True, api_name="/ask_llm")
-
-    # 2) Combine for final text
-    result = f"### 🔎 {q}\n\n{r2}\n\n{refs}"
-    st.markdown(result)
-
-    # Optionally produce "all at once" TTS
-    if full_audio:
-        complete_text = f"Complete response for query: {q}. {clean_for_speech(r2)} {clean_for_speech(refs)}"
-        audio_file_full = speak_with_edge_tts(complete_text)
-        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)
-        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)
-        st.write("### 📜 Long Refs")
-        play_and_download_audio(audio_file_refs)
-
-    # 3) Parse references
-    parsed = parse_arxiv_refs(refs)
-
-    # 4) Show references
-    st.write("## Individual Paper Lines (Up to 20)")
-    for i, ref in enumerate(parsed):
-        st.markdown(f"**Ref #{i+1}**:  {ref['line']}")
-        if ref['year'] in [2023, 2024]:
-            # TTS content: "Title + entire line"
-            tts_text = f"Title: {ref['title']}. Full content: {ref['line']}"
-            out_fn = generate_audio_filename(q, ref['title'], ref['line'])
-            tmp_mp3 = speak_with_edge_tts(tts_text)
-            if tmp_mp3 and os.path.exists(tmp_mp3):
-                # rename to out_fn
-                os.rename(tmp_mp3, out_fn)
-                # auto-play
-                auto_play_audio(out_fn)
-        st.write("---")
-
-    # Titles only block
-    if titles_summary:
-        # This was your older code - parse bracketed titles from each line
-        # to produce an all-in-one TTS if desired
-        lines = refs.split('\n')
-        titles = []
-        for line in lines:
-            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)
-            st.write("### 🔖 Titles (All-In-One)")
-            play_and_download_audio(audio_file_titles)
-
-    elapsed = time.time() - start
-    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
-
-    # 5) Save entire text as MD file
-    create_file(q, result, "md")
-
-    return result
-
 def process_with_gpt(text):
     """Process text with GPT-4"""
     if not text:
@@ -473,13 +295,13 @@ def process_with_gpt(text):
     with st.chat_message("user"):
         st.markdown(text)
     with st.chat_message("assistant"):
-        c = openai_client.chat.completions.create(
+        c = openai_client.ChatCompletion.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)
+        st.write("GPT-4: " + ans)
         create_file(text, ans, "md")
         st.session_state.messages.append({"role":"assistant","content":ans})
     return ans
@@ -491,20 +313,20 @@ def process_with_claude(text):
     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}]
+        r = claude_client.completions.create(
+            prompt=text,
+            model="claude-3",
+            max_tokens=1000
         )
-        ans = r.content[0].text
+        ans = r['completion']
         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
+# 📂 9. File Management
 def create_zip_of_files(md_files, mp3_files):
-    """Create zip with a short naming approach"""
+    """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:
@@ -542,7 +364,7 @@ def load_files_for_sidebar():
     groups = defaultdict(list)
     for f in all_files:
         fname = os.path.basename(f)
-        prefix = fname[:10]  # e.g. "2310_1205_"
+        prefix = fname[:10]  # e.g., "2310_1205_"
         groups[prefix].append(f)
 
     for prefix in groups:
@@ -613,87 +435,32 @@ def display_file_manager_sidebar(groups, sorted_prefixes):
                 ctime = datetime.fromtimestamp(os.path.getmtime(f)).strftime("%Y-%m-%d %H:%M:%S")
                 st.write(f"**{fname}** - {ctime}")
 
-# 🎯 11. Main Application
+# 🎯 10. Main Application
 def main():
     st.sidebar.markdown("### 🚲BikeAI🏆 Multi-Agent Research")
     tab_main = st.radio("Action:", ["🎤 Voice","📸 Media","🔍 ArXiv","📝 Editor"], horizontal=True)
 
-    # If you have a custom React component
-    mycomponent = components.declare_component("mycomponent", path="mycomponent")
-    val = mycomponent(my_input_value="Hello")
-
-    # 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)
-            elif 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)
-                elif run_option == "GPT-4o":
-                    process_with_gpt(edited_input)
-                elif run_option == "Claude-3.5":
-                    process_with_claude(edited_input)
+    # Placeholder for custom component if needed
+    # mycomponent = components.declare_component("mycomponent", path="mycomponent")
+    # val = mycomponent(my_input_value="Hello")
+
+    # Example input handling
+    # if val:
+    #     # Handle custom component input
+    #     pass
 
     if tab_main == "🔍 ArXiv":
         st.subheader("🔍 Query ArXiv")
         q = st.text_input("🔍 Query:")
 
         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)
-            if full_transcript:
-                save_full_transcript(q, result)
-
-        st.markdown("### Change Prompt & Re-Run")
-        q_new = st.text_input("🔄 Modify Query:")
-        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)
+        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 Query"):
+            perform_ai_lookup(q)
             if full_transcript:
-                save_full_transcript(q_new, result)
+                create_file(q, "Full transcript generated.", "md")  # Customize as needed
 
     elif tab_main == "🎤 Voice":
         st.subheader("🎤 Voice Input")
@@ -702,7 +469,7 @@ 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-4 History"])
         with t1:
             for c in st.session_state.chat_history:
                 st.write("**You:**", c["user"])
@@ -716,12 +483,11 @@ 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") + glob.glob("*.jpeg")
             if imgs:
-                c = st.slider("Cols", 1, 5, 3)
-                cols = st.columns(c)
+                cols = st.columns(st.slider("Cols", 1, 5, 3))
                 for i, f in enumerate(imgs):
-                    with cols[i % c]:
+                    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.")
@@ -729,28 +495,33 @@ def main():
             else:
                 st.write("No images found.")
         with tabs[1]:
-            vids = glob.glob("*.mp4")
+            vids = glob.glob("*.mp4") + glob.glob("*.avi") + glob.glob("*.mov")
             if vids:
                 for v in vids:
                     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.")
+                            a = process_video_with_gpt(v, "Describe this video.")
                             st.markdown(a)
             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("📝 File Editor")
+        # Example editor logic: list markdown files and allow editing
+        md_files = glob.glob("*.md")
+        if md_files:
+            selected_file = st.selectbox("Select a file to edit:", md_files)
+            with st.form("edit_form"):
+                new_content = st.text_area("✏️ Content:", open(selected_file, 'r', encoding='utf-8').read(), height=300)
+                submitted = st.form_submit_button("💾 Save")
+                if submitted:
+                    with open(selected_file, 'w', encoding='utf-8') as f:
+                        f.write(new_content)
+                    st.success(f"Updated {selected_file}!")
+                    st.session_state.should_rerun = True
         else:
-            st.write("Select a file from the sidebar to edit.")
+            st.write("No markdown files available to edit.")
 
     # File manager in sidebar
     groups, sorted_prefixes = load_files_for_sidebar()
@@ -776,7 +547,120 @@ def main():
 
     if st.session_state.should_rerun:
         st.session_state.should_rerun = False
-        st.rerun()
+        st.experimental_rerun()
+
+def parse_arxiv_papers(ref_text: str):
+    """
+    Splits the references into paper-level chunks.
+    Each paper starts with a number followed by a parenthesis, e.g., "1) [Title (Year)] Summary..."
+    Returns a list of dictionaries with 'title', 'summary', and 'year'.
+    Limits to 20 papers.
+    """
+    # Split based on patterns like "1) ", "2) ", etc.
+    chunks = re.split(r'\n?\d+\)\s+', ref_text)
+    # Remove any empty strings resulting from split
+    chunks = [chunk.strip() for chunk in chunks if chunk.strip()]
+    papers = []
+    for chunk in chunks[:20]:
+        # Extract title within brackets if present
+        title_match = re.search(r'\[([^\]]+)\]', chunk)
+        title = title_match.group(1).strip() if title_match else "No Title"
+        
+        # Extract year (assuming it's a 4-digit number within the title or summary)
+        year_match = re.search(r'\b(20\d{2})\b', chunk)
+        year = int(year_match.group(1)) if year_match else None
+        
+        # The entire chunk is considered the summary
+        summary = chunk
+        
+        papers.append({
+            'title': title,
+            'summary': summary,
+            'year': year
+        })
+    return papers
+
+def perform_ai_lookup(q):
+    """
+    Performs the Arxiv search and handles the processing of results.
+    Generates audio files for each paper (if year is 2023 or 2024).
+    """
+    st.write(f"## Query: {q}")
+
+    # 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")
+
+    # 2) Combine for final text output
+    result = f"### 🔎 {q}\n\n{r2}\n\n{refs}"
+    st.markdown(result)
+
+    # 3) Parse references into papers
+    papers = parse_arxiv_papers(refs)
+
+    # 4) Display each paper and generate audio if applicable
+    st.write("## Individual Papers (Up to 20)")
+    for idx, paper in enumerate(papers):
+        year_str = paper["year"] if paper["year"] else "Unknown Year"
+        st.markdown(f"**Paper #{idx+1}: {paper['title']}**  \n*Year:* {year_str}")
+        st.markdown(f"*Summary:* {paper['summary']}")
+        st.write("---")
+
+        # Generate TTS if year is 2023 or 2024
+        if paper["year"] in [2023, 2024]:
+            # Combine title and summary for TTS
+            tts_text = f"Title: {paper['title']}. Summary: {paper['summary']}"
+            # Generate a specialized filename
+            mp3_filename = generate_audio_filename(q, paper['title'], paper['summary'])
+            # Generate audio using Edge TTS
+            temp_mp3 = speak_with_edge_tts(tts_text, out_fn=mp3_filename)
+            if temp_mp3 and os.path.exists(mp3_filename):
+                # Embed the audio player with auto-play and download link
+                auto_play_audio(mp3_filename)
+
+    # Optionally save the full transcript
+    st.write("### Transcript")
+    st.markdown(result)
+    create_file(q, result, "md")
+
+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.ChatCompletion.create(
+            model=st.session_state["openai_model"],
+            messages=st.session_state.messages,
+            stream=False
+        )
+        ans = c.choices[0].message.content
+        st.write("GPT-4: " + 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.completions.create(
+            prompt=text,
+            model="claude-3",
+            max_tokens=1000
+        )
+        ans = r['completion']
+        st.write("Claude-3.5: " + ans)
+        create_file(text, ans, "md")
+        st.session_state.chat_history.append({"user":text,"claude":ans})
+    return ans
 
+# Run the app
 if __name__ == "__main__":
     main()