Update app.py

app.py

@@ -1,525 +1,254 @@
 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, openai, base64, cv2, glob, os, re, time, zipfile
 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
+import asyncio, edge_tts
 
-# 🔧 Config & Setup
+# 🎯 1. Core Configuration & Setup
 st.set_page_config(
-    page_title="🚲BikeAI🏆 Claude/GPT Research",
-    page_icon="🚲🏆",
-    layout="wide",
-    initial_sidebar_state="auto",
-    menu_items={
-        'Get Help': 'https://huggingface.co/awacke1',
-        'Report a bug': 'https://huggingface.co/spaces/awacke1',
-        'About': "🚲BikeAI🏆 Claude/GPT Research AI"
-    }
+    page_title="🚲BikeAI Research", page_icon="🚲", layout="wide",
+    menu_items={'About': "🚲BikeAI Research Assistant"}
 )
 load_dotenv()
 
-openai_api_key = os.getenv('OPENAI_API_KEY', "")
-anthropic_key = os.getenv('ANTHROPIC_API_KEY_3', "")
-if 'OPENAI_API_KEY' in st.secrets:
-    openai_api_key = st.secrets['OPENAI_API_KEY']
-if 'ANTHROPIC_API_KEY' in st.secrets:
-    anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
-
-openai.api_key = openai_api_key
+# 🔑 2. API Setup
+openai_api_key = st.secrets.get('OPENAI_API_KEY', os.getenv('OPENAI_API_KEY', ""))
+anthropic_key = st.secrets.get('ANTHROPIC_API_KEY', os.getenv('ANTHROPIC_API_KEY_3', ""))
+openai_client = OpenAI(api_key=openai_api_key, organization=os.getenv('OPENAI_ORG_ID'))
 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')
-
-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 '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
-
-# 🎨 Minimal 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": "🎵",
-}
-
-def clean_for_speech(text: str) -> str:
-    text = text.replace("\n", " ")
-    text = text.replace("</s>", " ")
-    text = text.replace("#", "")
-    # Remove links
-    text = re.sub(r"\(https?:\/\/[^\)]+\)", "", text)
-    text = re.sub(r"\s+", " ", text).strip()
-    return text
 
+# 📝 3. Session State
+for key in ['transcript_history', 'chat_history', 'messages', 'viewing_prefix', 'should_rerun', 'old_val']:
+    if key not in st.session_state:
+        st.session_state[key] = [] if key in ['transcript_history', 'chat_history', 'messages'] else None
+
+st.session_state.setdefault('openai_model', "gpt-4o-2024-05-13")
+
+# 🧠 4. Content Processing
+def get_high_info_terms(text: str) -> list:
+    """Extract high-information terms from text"""
+    stop_words = set([
+        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with',
+        'by', 'from', 'up', 'about', 'into', 'over', 'after', 'be', 'been', 'being', 'have',
+        'has', 'had', 'do', 'does', 'did', 'will', 'would', 'should', 'could', 'this', 'that'
+    ])
+
+    key_phrases = [
+        'artificial intelligence', 'machine learning', 'deep learning', 'neural network',
+        'natural language', 'computer vision', 'data science', 'reinforcement learning',
+        'large language model', 'transformer model', 'quantum computing', 'arxiv search'
+    ]
+
+    preserved_phrases = [phrase for phrase in key_phrases if phrase in text.lower()]
+    text = text.lower()
+    for phrase in preserved_phrases:
+        text = text.replace(phrase, '')
+
+    words = [word.lower() for word in re.findall(r'\b\w+(?:-\w+)*\b', text)
+             if len(word) > 3 and word.lower() not in stop_words
+             and not word.isdigit() and any(c.isalpha() for c in word)]
+
+    unique_terms = list(dict.fromkeys(preserved_phrases + words))
+    return unique_terms[:5]
+
+# 📁 5. File Operations
 def generate_filename(content, file_type="md"):
+    """Generate filename with high-information terms"""
     prefix = datetime.now().strftime("%y%m_%H%M") + "_"
-    words = re.findall(r"\w+", content)
-    name_text = '_'.join(words[:3]) if words else 'file'
-    filename = f"{prefix}{name_text}.{file_type}"
-    return filename
+    info_terms = get_high_info_terms(content)
+    name_text = '_'.join(term.replace(' ', '-') for term in info_terms) if info_terms else 'file'
+    return f"{prefix}{name_text[:100]}.{file_type}"
 
 def create_file(prompt, response, file_type="md"):
-    filename = generate_filename(response.strip() if response.strip() else prompt.strip(), file_type)
+    """Create a new file with generated filename"""
+    filename = generate_filename(response.strip() or prompt.strip(), file_type)
     with open(filename, 'w', encoding='utf-8') as f:
-        f.write(prompt + "\n\n" + response)
+        f.write(f"{prompt}\n\n{response}")
     return filename
 
-def get_download_link(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>'
-
-@st.cache_resource
-def speech_synthesis_html(result):
-    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)
+def create_zip_of_files(md_files, mp3_files):
+    """Create zip with intelligent naming"""
+    all_files = [f for f in md_files if 'readme.md' not in f.lower()] + mp3_files
+    if not all_files:
+        return None
+
+    content = " ".join(open(f, 'r', encoding='utf-8').read() if f.endswith('.md')
+                      else os.path.basename(f) for f in all_files)
+    
+    timestamp = datetime.now().strftime("%y%m_%H%M")
+    info_terms = get_high_info_terms(content)[:3]
+    zip_name = f"{timestamp}_{'_'.join(t.replace(' ', '-') for t in info_terms)}.zip"
+    
+    with zipfile.ZipFile(zip_name, 'w') as z:
+        for f in all_files:
+            z.write(f)
+    return zip_name
+
+# 🔊 6. Audio Processing
+def clean_for_speech(text: str) -> str:
+    """Prepare text for speech synthesis"""
+    text = re.sub(r'\n|</s>|#|\(https?:\/\/[^\)]+\)|\s+', ' ', text)
+    return text.strip()
 
 async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0):
+    """Generate audio file 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,"mp3")
+    communicate = edge_tts.Communicate(text, voice, rate=f"{rate:+d}%", pitch=f"{pitch:+d}Hz")
+    out_fn = generate_filename(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"""
     return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch))
 
-def play_and_download_audio(file_path):
-    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>'
-        st.markdown(dl_link, unsafe_allow_html=True)
+# 🎬 7. Media Processing
+def process_image(image_path, user_prompt):
+    """Process image with GPT-4V"""
+    with open(image_path, "rb") as imgf:
+        b64img = base64.b64encode(imgf.read()).decode("utf-8")
+    resp = openai_client.chat.completions.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}"}}
+            ]}
+        ],
+        temperature=0.0,
+    )
+    return resp.choices[0].message.content
 
+# 🤖 8. AI Integration
 def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False):
+    """Perform Arxiv search and generate audio summaries"""
     start = time.time()
     client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-    r = client.predict(q,20,"Semantic Search","mistralai/Mixtral-8x7B-Instruct-v0.1",api_name="/update_with_rag_md")
-    refs = r[0]
-    r2 = client.predict(q,"mistralai/Mixtral-8x7B-Instruct-v0.1",True,api_name="/ask_llm")
-    result = f"### 🔎 {q}\n\n{r2}\n\n{refs}"
+    refs = client.predict(q, 20, "Semantic Search", "mistralai/Mixtral-8x7B-Instruct-v0.1",
+                         api_name="/update_with_rag_md")[0]
+    answer = client.predict(q, "mistralai/Mixtral-8x7B-Instruct-v0.1", True, api_name="/ask_llm")
+    result = f"### 🔎 {q}\n\n{answer}\n\n{refs}"
 
     st.markdown(result)
 
-    # Generate full audio version if requested  
     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)
+        complete_text = f"Query: {q}. {clean_for_speech(answer)} {clean_for_speech(refs)}"
         st.write("### 📚 Complete Audio Response")
-        play_and_download_audio(audio_file_full)
+        play_and_download_audio(speak_with_edge_tts(complete_text))
 
     if vocal_summary:
-        main_text = clean_for_speech(r2)
-        audio_file_main = speak_with_edge_tts(main_text)
-        st.write("### 🎙️ Vocal Summary (Short Answer)")
-        play_and_download_audio(audio_file_main)
+        st.write("### 🎙️ Vocal Summary")
+        play_and_download_audio(speak_with_edge_tts(clean_for_speech(answer)))
 
     if extended_refs:
-        summaries_text = "Here are the summaries from the references: " + refs.replace('"','')
-        summaries_text = clean_for_speech(summaries_text)
-        audio_file_refs = speak_with_edge_tts(summaries_text)
-        st.write("### 📜 Extended References & Summaries")
-        play_and_download_audio(audio_file_refs)
+        st.write("### 📜 Extended References")
+        play_and_download_audio(speak_with_edge_tts(
+            "Reference summaries: " + clean_for_speech(refs)))
 
     if titles_summary:
-        titles = []
-        for line in refs.split('\n'):
-            m = re.search(r"\[([^\]]+)\]", line)
-            if m:
-                titles.append(m.group(1))
+        titles = [m.group(1) for m in re.finditer(r"\[([^\]]+)\]", refs)]
         if titles:
-            titles_text = "Here are the titles of the papers: " + ", ".join(titles)
-            titles_text = clean_for_speech(titles_text)
-            audio_file_titles = speak_with_edge_tts(titles_text)
             st.write("### 🔖 Paper Titles")
-            play_and_download_audio(audio_file_titles)
+            play_and_download_audio(speak_with_edge_tts(
+                "Paper titles: " + ", ".join(titles)))
 
-    elapsed = time.time()-start
-    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
-    create_file(q, result, "md")
+    st.write(f"**Time:** {time.time()-start:.2f} s")
+    create_file(q, result)
     return result
 
-def process_image(image_path, user_prompt):
-    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(
-        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}"}}
-            ]}
-        ],
-        temperature=0.0,
-    )
-    return resp.choices[0].message.content
-
-def process_audio(audio_path):
-    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
-
-def process_video(video_path, seconds_per_frame=1):
-    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)
-    frames_b64 = []
-    for i in range(0, total, skip):
-        vid.set(cv2.CAP_PROP_POS_FRAMES, i)
-        ret, frame = vid.read()
-        if not ret: break
-        _, buf = cv2.imencode(".jpg", frame)
-        frames_b64.append(base64.b64encode(buf).decode("utf-8"))
-    vid.release()
-    return frames_b64
-
-def process_video_with_gpt(video_path, prompt):
-    frames = process_video(video_path)
-    resp = openai_client.chat.completions.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]
-            ]}
-        ]
-    )
-    return resp.choices[0].message.content
-
 def process_with_gpt(text):
-    if not text: return
+    """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("user"): st.markdown(text)
     with st.chat_message("assistant"):
-        c = openai_client.chat.completions.create(
+        resp = 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")
+        ans = resp.choices[0].message.content
+        st.write(f"GPT-4o: {ans}")
+        create_file(text, ans)
         st.session_state.messages.append({"role":"assistant","content":ans})
     return ans
 
 def process_with_claude(text):
-    if not text: return
-    with st.chat_message("user"):
-        st.markdown(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(
+        resp = 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")
+        ans = resp.content[0].text
+        st.write(f"Claude-3.5: {ans}")
+        create_file(text, ans)
         st.session_state.chat_history.append({"user":text,"claude":ans})
     return ans
 
-def create_zip_of_files(md_files, mp3_files):
-    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:
-        return None
-    stems = [os.path.splitext(os.path.basename(f))[0] for f in all_files]
-    joined = "_".join(stems)
-    if len(joined) > 50:
-        joined = joined[:50] + "_etc"
-    zip_name = f"{joined}.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():
-    md_files = glob.glob("*.md")
-    mp3_files = glob.glob("*.mp3")
-
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-
-    all_files = md_files + mp3_files
-
-    groups = defaultdict(list)
-    for f in all_files:
-        fname = os.path.basename(f)
-        prefix = fname[:10]
-        groups[prefix].append(f)
-
-    for prefix in groups:
-        groups[prefix].sort(key=lambda x: os.path.getmtime(x), reverse=True)
-
-    sorted_prefixes = sorted(groups.keys(), key=lambda pre: max(os.path.getmtime(x) for x in groups[pre]), reverse=True)
-    return groups, sorted_prefixes
-
-def extract_keywords_from_md(files):
-    text = ""
-    for f in files:
-        if f.endswith(".md"):
-            c = open(f,'r',encoding='utf-8').read()
-            text += " " + c
-    words = re.findall(r"\w+", text.lower())
-    unique_words = []
-    for w in words:
-        if w not in unique_words:
-            unique_words.append(w)
-        if len(unique_words) == 5:
-            break
-    return unique_words
-
-def display_file_manager_sidebar(groups, sorted_prefixes):
-    st.sidebar.title("🎵 Audio & Document Manager")
-
-    all_md = []
-    all_mp3 = []
-    for prefix in groups:
-        for f in groups[prefix]:
-            if f.endswith(".md"):
-                all_md.append(f)
-            elif f.endswith(".mp3"):
-                all_mp3.append(f)
-
-    top_bar = st.sidebar.columns(3)
-    with top_bar[0]:
-        if st.button("🗑 Del All MD"):
-            for f in all_md:
-                os.remove(f)
-            st.session_state.should_rerun = True
-    with top_bar[1]:
-        if st.button("🗑 Del All MP3"):
-            for f in all_mp3:
-                os.remove(f)
-            st.session_state.should_rerun = True
-    with top_bar[2]:
-        if st.button("⬇️ Zip All"):
-            z = create_zip_of_files(all_md, all_mp3)
-            if z:
-                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)}) - Keywords: {keywords_str}", expanded=True):
-            c1,c2 = st.columns(2)
-            with c1:
-                if st.button("👀View Group", key="view_group_"+prefix):
-                    st.session_state.viewing_prefix = prefix
-            with c2:
-                if st.button("🗑Del Group", key="del_group_"+prefix):
-                    for f in files:
-                        os.remove(f)
-                    st.success(f"Deleted all files in group {prefix} successfully!")
-                    st.session_state.should_rerun = True
-
-            for f in files:
-                fname = os.path.basename(f)
-                ctime = datetime.fromtimestamp(os.path.getmtime(f)).strftime("%Y-%m-%d %H:%M:%S")
-                st.write(f"**{fname}** - {ctime}")
-
-def run_selected_model(option, user_input):
-    user_input = user_input.strip()
-    if option == "Arxiv":
-        st.subheader("Arxiv Only Results:")
-        perform_ai_lookup(user_input, vocal_summary=True, extended_refs=False, titles_summary=True)
-    elif option == "GPT-4o":
-        process_with_gpt(user_input)
-    elif option == "Claude-3.5":
-        process_with_claude(user_input)
+def play_and_download_audio(file_path):
+    """Play and provide download link for audio file"""
+    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>'
+        st.markdown(dl_link, unsafe_allow_html=True)
 
+# 🎯 9. Main Application
 def main():
-    st.sidebar.markdown("### 🚲BikeAI🏆 Multi-Agent Research AI")
-    tab_main = st.radio("Action:",["🎤 Voice Input","📸 Media Gallery","🔍 Search ArXiv","📝 File Editor"],horizontal=True)
-
-    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 your detected input:", value=val_stripped, height=100)
-        run_option = st.selectbox("Select AI Model:", ["Arxiv", "GPT-4o", "Claude-3.5"])
-        col1, col2 = st.columns(2)
-        with col1:
-            autorun = st.checkbox("AutoRun on input change", value=False)
-        with col2:
-            full_audio = st.checkbox("Generate Complete Audio", value=False, 
-                                   help="Generate audio for the complete response including all papers and summaries")
-
-        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)
-            else:
-                run_selected_model(run_option, edited_input)
-        else:
-            if st.button("Process Input"):
-                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)
-                else:
-                    run_selected_model(run_option, edited_input)
+    st.sidebar.title("🚲BikeAI Research")
+    tab_main = st.radio("Action:", ["🔍 Search ArXiv", "🎤 Voice", "📸 Media", "📝 Files"], horizontal=True)
 
     if tab_main == "🔍 Search ArXiv":
-        st.subheader("🔍 Search ArXiv")
         q = st.text_input("Research query:")
-
-        st.markdown("### 🎛️ Audio Generation Options")
-        vocal_summary = st.checkbox("🎙️ Vocal Summary (Short Answer)", value=True)
-        extended_refs = st.checkbox("📜 Extended References & Summaries (Long)", value=False)
-        titles_summary = st.checkbox("🔖 Paper Titles Only", value=True)
-        full_audio = st.checkbox("📚 Generate Complete Audio Response", value=False,
-                               help="Generate audio for the complete response including all papers and summaries")
-
-        if q and st.button("Run ArXiv Query"):
-            perform_ai_lookup(q, vocal_summary=vocal_summary, extended_refs=extended_refs, 
-                            titles_summary=titles_summary, full_audio=full_audio)
-
-    elif tab_main == "🎤 Voice Input":
-        st.subheader("🎤 Voice Recognition")
-        user_text = st.text_area("Message:", height=100)
-        user_text = user_text.strip().replace('\n', ' ')
+        st.markdown("### 🎛️ Audio Options")
+        cols = st.columns(4)
+        options = {
+            'vocal_summary': cols[0].checkbox("🎙️ Summary", value=True),
+            'extended_refs': cols[1].checkbox("📜 References", value=False),
+            'titles_summary': cols[2].checkbox("🔖 Titles", value=True),
+            'full_audio': cols[3].checkbox("📚 Full Response", value=False,
+                help="Generate complete audio including papers")
+        }
+        if q and st.button("Search"):
+            perform_ai_lookup(q, **options)
+
+    elif tab_main == "🎤 Voice":
+        user_text = st.text_area("Message:", height=100).strip()
+        model = st.selectbox("Model:", ["GPT-4o", "Claude-3.5"])
         if st.button("Send 📨"):
-            process_with_gpt(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"])
-
-    elif tab_main == "📸 Media Gallery":
-        st.header("🎬 Media Gallery - Images and Videos")
-        tabs = st.tabs(["🖼️ Images", "🎥 Video"])
-        with tabs[0]:
-            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):
-                    with cols[i%c]:
-                        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)
-            else:
-                st.write("No images found.")
-        with tabs[1]:
-            vids = glob.glob("*.mp4")
-            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.")
-                            st.markdown(a)
+            if model == "GPT-4o":
+                process_with_gpt(user_text)
             else:
-                st.write("No videos found.")
-
-    elif tab_main == "📝 File 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
-        else:
-            st.write("Select a file from the sidebar to edit.")
-
-    groups, sorted_prefixes = load_files_for_sidebar()
-    display_file_manager_sidebar(groups, sorted_prefixes)
-
-    if st.session_state.viewing_prefix and st.session_state.viewing_prefix in groups:
-        st.write("---")
-        st.write(f"**Viewing Group:** {st.session_state.viewing_prefix}")
-        for f in groups[st.session_state.viewing_prefix]:
-            fname = os.path.basename(f)
-            ext = os.path.splitext(fname)[1].lower().strip('.')
-            st.write(f"### {fname}")
-            if ext == "md":
-                content = open(f,'r',encoding='utf-8').read()
-                st.markdown(content)
-            elif ext == "mp3":
-                st.audio(f)
-            else:
-                st.markdown(get_download_link(f), unsafe_allow_html=True)
-        if st.button("Close Group View"):
-            st.session_state.viewing_prefix = None
-
-    if st.session_state.should_rerun:
-        st.session_state.should_rerun = False
-        st.rerun()
+                process_with_claude(user_text)
 
-if __name__=="__main__":
+    elif tab_main == "📸 Media":
+        tabs = st.tabs(["🖼️ Images", "🎥 Video"])
+        with tabs[0]:
+            for f in glob.glob("*.png") + glob.glob("*.jpg"):
+                st.image(Image.open(f))
+                if st.button(f"Analyze {os.path.basename(f)}", key=f"analyze_{f}"):
+                    st.markdown(process_image(f, "Describe this image."))
+
+    elif tab_main == "📝 Files":
+        md_files = [f for f in glob.glob("*.md") if 'readme.md' not in f.lower()]
+        mp3_files = glob.glob("*.mp3")
+        if st.button("Create Archive"):
+            zip_file = create_zip_of_files(md_files, mp3_files)
+            if zip_file:
+                with open(zip_file, "rb") as f:
+                    st.download_button("Download Archive", f, zip_file)
+
+if __name__ == "__main__":
     main()