Spaces:

awacke1
/

RescuerOfStolenBikes

Running

App Files Files Community

awacke1 commited on about 1 month ago

Commit

2a7e2ce

•

1 Parent(s): 8cb9f0c

Update app.py

Browse files

Files changed (1) hide show

app.py +863 -348

app.py CHANGED Viewed

@@ -21,7 +21,7 @@ from audio_recorder_streamlit import audio_recorder
 from bs4 import BeautifulSoup
 from collections import deque
 from dotenv import load_dotenv
-from gradio_client import Client
 from huggingface_hub import InferenceClient
 from io import BytesIO
 from moviepy.editor import VideoFileClip
@@ -30,166 +30,19 @@ 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
-# Configuration constants
-Site_Name = '🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI'
-title = "🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI"
-helpURL = 'https://huggingface.co/awacke1'
-bugURL = 'https://huggingface.co/spaces/awacke1'
-icons = '🚲🏆'
-# Cookie Management
-def get_cookie_manager():
-    return stx.CookieManager()
-# State Management
-def update_transcript_state(new_transcript):
-    """Update transcript in both session state and cookie"""
-    cookie_manager = get_cookie_manager()
-    if new_transcript is not None:
-        st.session_state.voice_transcript = new_transcript
-        cookie_manager.set('voice_transcript', new_transcript)
-    return new_transcript
-# Speech Recognition HTML Template
-speech_recognition_html = """
-<!DOCTYPE html>
-<html>
-<head>
-    <style>
-        body { font-family: sans-serif; padding: 20px; }
-        button { padding: 10px 20px; margin: 10px 5px; }
-        #status { margin: 10px 0; padding: 10px; background: #e8f5e9; }
-        #output {
-            white-space: pre-wrap;
-            padding: 15px;
-            background: #f5f5f5;
-            margin: 10px 0;
-            min-height: 100px;
-            max-height: 300px;
-            overflow-y: auto;
-        }
-    </style>
-</head>
-<body>
-    <div>
-        <button id="startBtn">Start</button>
-        <button id="stopBtn" disabled>Stop</button>
-        <button id="clearBtn">Clear</button>
-    </div>
-    <div id="status">Ready</div>
-    <div id="output"></div>
-    <script>
-        let recognition;
-        let fullTranscript = '';
-        // Function to save state to localStorage
-        function saveTranscriptState(text) {
-            localStorage.setItem('voiceTranscript', text);
-            // Send to Streamlit
-            window.parent.postMessage({
-                type: 'streamlit:setComponentValue',
-                value: JSON.stringify({ transcript: text })
-            }, '*');
-        }
-        // Function to load state from localStorage
-        function loadTranscriptState() {
-            return localStorage.getItem('voiceTranscript') || '';
-        }
-        if ('webkitSpeechRecognition' in window) {
-            recognition = new webkitSpeechRecognition();
-            recognition.continuous = true;
-            recognition.interimResults = true;
-            // Load any existing transcript
-            fullTranscript = loadTranscriptState();
-            document.getElementById('output').textContent = fullTranscript;
-            recognition.onstart = () => {
-                document.getElementById('status').textContent = 'Listening...';
-                document.getElementById('startBtn').disabled = true;
-                document.getElementById('stopBtn').disabled = false;
-            };
-            recognition.onend = () => {
-                document.getElementById('status').textContent = 'Click Start to begin';
-                document.getElementById('startBtn').disabled = false;
-                document.getElementById('stopBtn').disabled = true;
-            };
-            recognition.onresult = (event) => {
-                let interimTranscript = '';
-                let finalTranscript = '';
-                for (let i = event.resultIndex; i < event.results.length; i++) {
-                    const transcript = event.results[i][0].transcript;
-                    if (event.results[i].isFinal) {
-                        finalTranscript += transcript + ' ';
-                        fullTranscript += transcript + ' ';
-                    } else {
-                        interimTranscript += transcript;
-                    }
-                }
-                if (finalTranscript) {
-                    saveTranscriptState(fullTranscript);
-                }
-                const output = document.getElementById('output');
-                output.textContent = fullTranscript + interimTranscript;
-                output.scrollTop = output.scrollHeight;
-            };
-            recognition.onerror = (event) => {
-                document.getElementById('status').textContent = 'Error: ' + event.error;
-                document.getElementById('startBtn').disabled = false;
-                document.getElementById('stopBtn').disabled = true;
-            };
-            // Button handlers
-            document.getElementById('startBtn').onclick = () => {
-                try {
-                    recognition.start();
-                } catch (e) {
-                    document.getElementById('status').textContent = 'Error starting: ' + e;
-                }
-            };
-            document.getElementById('stopBtn').onclick = () => recognition.stop();
-            document.getElementById('clearBtn').onclick = () => {
-                fullTranscript = '';
-                document.getElementById('output').textContent = '';
-                saveTranscriptState('');
-                localStorage.removeItem('voiceTranscript');
-            };
-            // Auto-start and load saved transcript on page load
-            window.addEventListener('load', () => {
-                const savedTranscript = loadTranscriptState();
-                if (savedTranscript) {
-                    fullTranscript = savedTranscript;
-                    document.getElementById('output').textContent = savedTranscript;
-                    saveTranscriptState(savedTranscript);
-                }
-                setTimeout(() => document.getElementById('startBtn').click(), 1000);
-            });
-        } else {
-            document.getElementById('status').textContent = 'Speech recognition not supported in this browser';
-            document.getElementById('startBtn').disabled = true;
-            document.getElementById('stopBtn').disabled = true;
-        }
-    </script>
-</body>
-</html>
-"""
-# Streamlit page configuration
 st.set_page_config(
     page_title=title,
     page_icon=icons,
@@ -202,10 +55,7 @@ st.set_page_config(
     }
 )
-# Load environment variables and initialize clients
 load_dotenv()
 # OpenAI setup
@@ -218,27 +68,353 @@ openai_client = OpenAI(
     organization=os.getenv('OPENAI_ORG_ID')
 )
-# Claude setup
 anthropic_key = os.getenv("ANTHROPIC_API_KEY_3")
 if anthropic_key == None:
     anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
 claude_client = anthropic.Anthropic(api_key=anthropic_key)
-# Initialize session states
 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-4-vision-preview"
 if "messages" not in st.session_state:
     st.session_state.messages = []
-if 'voice_transcript' not in st.session_state:
-    st.session_state.voice_transcript = ""
-# Processing Functions
 def process_with_gpt(text_input):
-    """Process text with GPT-4."""
     if text_input:
         st.session_state.messages.append({"role": "user", "content": text_input})
@@ -255,9 +431,10 @@ def process_with_gpt(text_input):
                 stream=False
             )
             return_text = completion.choices[0].message.content
-            st.write("GPT-4: " + return_text)
-            filename = generate_filename("GPT-4: " + return_text, "md")
             create_file(filename, text_input, return_text)
             st.session_state.messages.append({"role": "assistant", "content": return_text})
             return return_text
@@ -265,6 +442,7 @@ def process_with_gpt(text_input):
 def process_with_claude(text_input):
     """Process text with Claude."""
     if text_input:
         with st.chat_message("user"):
             st.markdown(text_input)
@@ -279,6 +457,7 @@ def process_with_claude(text_input):
             response_text = response.content[0].text
             st.write("Claude: " + response_text)
             filename = generate_filename("Claude: " + response_text, "md")
             create_file(filename, text_input, response_text)
@@ -288,55 +467,420 @@ def process_with_claude(text_input):
             })
             return response_text
-def perform_ai_lookup(query):
-    """Perform ArXiv search and analysis."""
-    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-    start_time = time.strftime("%Y-%m-%d %H:%M:%S")
-    response1 = client.predict(
-        query,
-        20,
-        "Semantic Search",
-        "mistralai/Mixtral-8x7B-Instruct-v0.1",
-        api_name="/update_with_rag_md"
-    )
-    Question = '### 🔎 ' + query + '\r\n'
-    References = response1[0]
-    ReferenceLinks = extract_urls(References)
-    results = ''
-    response2 = client.predict(
-        query,
-        "mistralai/Mixtral-8x7B-Instruct-v0.1",
-        True,
-        api_name="/ask_llm"
-    )
-    if len(response2) > 10:
-        Answer = response2
-        results = Question + '\r\n' + Answer + '\r\n' + References + '\r\n' + ReferenceLinks
-        st.markdown(results)
-    end_time = time.strftime("%Y-%m-%d %H:%M:%S")
-    start_timestamp = time.mktime(time.strptime(start_time, "%Y-%m-%d %H:%M:%S"))
-    end_timestamp = time.mktime(time.strptime(end_time, "%Y-%m-%d %H:%M:%S"))
-    elapsed_seconds = end_timestamp - start_timestamp
-    st.write('🔍Run Complete')
-    st.write(f"Start time: {start_time}")
-    st.write(f"Finish time: {end_time}")
-    st.write(f"Elapsed time: {elapsed_seconds:.2f} seconds")
-    filename = generate_filename(query, "md")
-    create_file(filename, query, results)
-    return results
 def main():
     st.sidebar.markdown("### 🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI")
-    # Initialize cookie manager
-    cookie_manager = get_cookie_manager()
     tab_main = st.radio("Choose Action:",
                         ["🎤 Voice Input", "💬 Chat", "📸 Media Gallery", "🔍 Search ArXiv", "📝 File Editor"],
                         horizontal=True)
@@ -344,78 +888,112 @@ def main():
     if tab_main == "🎤 Voice Input":
         st.subheader("Voice Recognition")
-        # Initialize/restore state from cookie
-        saved_transcript = cookie_manager.get('voice_transcript')
-        if saved_transcript and not st.session_state.voice_transcript:
-            st.session_state.voice_transcript = saved_transcript
         # Display speech recognition component
-        st.components.v1.html(speech_recognition_html, height=400)
-        # Handle transcript updates with JSON parsing
-        transcript_receiver = st.components.v1.html("""
-            <script>
-                window.addEventListener('message', function(e) {
-                    if (e.data && e.data.type === 'streamlit:setComponentValue') {
-                        try {
-                            const data = JSON.parse(e.data.value);
-                            if (data.transcript !== undefined) {
-                                window.Streamlit.setComponentValue(data);
-                            }
-                        } catch (err) {
-                            console.error('Error parsing transcript data:', err);
-                        }
-                    }
-                });
-            </script>
         """, height=0)
-        # Update state if we received new transcript
-        if transcript_receiver and isinstance(transcript_receiver, dict):
-            new_transcript = transcript_receiver.get('transcript', '')
-            update_transcript_state(new_transcript)
-        # Display transcript
-        st.markdown("### Processed Voice Input:")
-        transcript_text = st.text_area(
-            "Voice Transcript",
-            value=st.session_state.voice_transcript if isinstance(st.session_state.voice_transcript, str) else "",
-            height=100,
-            key=f"voice_transcript_display_{int(time.time())}"  # Unique key to force refresh
-        )
-        # Process buttons
-        col1, col2, col3 = st.columns(3)
-        with col1:
-            if st.button("Process with GPT"):
-                if st.session_state.voice_transcript:
-                    st.markdown("### GPT Response:")
-                    gpt_response = process_with_gpt(st.session_state.voice_transcript)
-                    st.markdown(gpt_response)
-        with col2:
-            if st.button("Process with Claude"):
-                if st.session_state.voice_transcript:
-                    st.markdown("### Claude Response:")
-                    claude_response = process_with_claude(st.session_state.voice_transcript)
-                    st.markdown(claude_response)
-        with col3:
-            if st.button("Clear Transcript"):
-                update_transcript_state("")
-                st.experimental_rerun()
-        if st.session_state.voice_transcriptif st.session_state.voice_transcript:
-            if st.button("Search ArXiv"):
-                st.markdown("### ArXiv Search Results:")
-                arxiv_results = perform_ai_lookup(st.session_state.voice_transcript)
-                st.markdown(arxiv_results)
-    elif tab_main == "💬 Chat":
         # Model Selection
         model_choice = st.sidebar.radio(
             "Choose AI Model:",
-            ["GPT-4", "Claude-3", "GPT+Claude+Arxiv"]
         )
         # Chat Interface
@@ -423,33 +1001,35 @@ def main():
         if st.button("Send 📨"):
             if user_input:
-                if model_choice == "GPT-4":
                     gpt_response = process_with_gpt(user_input)
                 elif model_choice == "Claude-3":
                     claude_response = process_with_claude(user_input)
-                else:  # Both + Arxiv
                     col1, col2, col3 = st.columns(3)
-                    with col1:
-                        st.subheader("GPT-4:")
-                        try:
-                            gpt_response = process_with_gpt(user_input)
-                        except:
-                            st.write('GPT-4 out of tokens')
                     with col2:
-                        st.subheader("Claude-3:")
                         try:
                             claude_response = process_with_claude(user_input)
                         except:
-                            st.write('Claude-3 out of tokens')
                     with col3:
-                        st.subheader("Arxiv Search:")
                         with st.spinner("Searching ArXiv..."):
                             results = perform_ai_lookup(user_input)
                             st.markdown(results)
         # Display Chat History
         st.subheader("Chat History 📜")
-        tab1, tab2 = st.tabs(["Claude History", "GPT-4 History"])
         with tab1:
             for chat in st.session_state.chat_history:
@@ -469,7 +1049,7 @@ def main():
         query = st.text_input("Enter your research query:")
         if query:
             with st.spinner("Searching ArXiv..."):
-                results = perform_ai_lookup(query)
                 st.markdown(results)
     elif tab_main == "📝 File Editor":
@@ -480,75 +1060,10 @@ def main():
                 with open(st.session_state.current_file, 'w', encoding='utf-8') as file:
                     file.write(new_content)
                 st.success("File updated successfully!")
     # Always show file manager in sidebar
     display_file_manager()
-# Utility functions for file management
-def generate_filename(prompt, file_type):
-    """Generate a filename based on prompt and time."""
-    central = pytz.timezone('US/Central')
-    safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
-    replaced_prompt = re.sub(r'[<>:"/\\|?*\n]', ' ', prompt)
-    safe_prompt = re.sub(r'\s+', ' ', replaced_prompt).strip()[:230]
-    return f"{safe_date_time}_{safe_prompt}.{file_type}"
-def create_file(filename, prompt, response):
-    """Create and save a file."""
-    with open(filename, 'w', encoding='utf-8') as file:
-        file.write(prompt + "\n\n" + response)
-def load_file(file_name):
-    """Load file content."""
-    with open(file_name, "r", encoding='utf-8') as file:
-        return file.read()
-def create_zip_of_files(files):
-    """Create zip archive of files."""
-    zip_name = "all_files.zip"
-    with zipfile.ZipFile(zip_name, 'w') as zipf:
-        for file in files:
-            zipf.write(file)
-    return zip_name
-def get_download_link(file):
-    """Create download link for file."""
-    with open(file, "rb") as f:
-        contents = f.read()
-    b64 = base64.b64encode(contents).decode()
-    return f'<a href="data:file/txt;base64,{b64}" download="{os.path.basename(file)}">Download {os.path.basename(file)}📂</a>'
-def extract_urls(text):
-    """Extract URLs from text."""
-    try:
-        date_pattern = re.compile(r'### (\d{2} \w{3} \d{4})')
-        abs_link_pattern = re.compile(r'\[(.*?)\]\((https://arxiv\.org/abs/\d+\.\d+)\)')
-        pdf_link_pattern = re.compile(r'\[⬇️\]\((https://arxiv\.org/pdf/\d+\.\d+)\)')
-        title_pattern = re.compile(r'### \d{2} \w{3} \d{4} \| \[(.*?)\]')
-        date_matches = date_pattern.findall(text)
-        abs_link_matches = abs_link_pattern.findall(text)
-        pdf_link_matches = pdf_link_pattern.findall(text)
-        title_matches = title_pattern.findall(text)
-        markdown_text = ""
-        for i in range(len(date_matches)):
-            date = date_matches[i]
-            title = title_matches[i]
-            abs_link = abs_link_matches[i][1]
-            pdf_link = pdf_link_matches[i]
-            markdown_text += f"**Date:** {date}\n\n"
-            markdown_text += f"**Title:** {title}\n\n"
-            markdown_text += f"**Abstract Link:** [{abs_link}]({abs_link})\n\n"
-            markdown_text += f"**PDF Link:** [{pdf_link}]({pdf_link})\n\n"
-            markdown_text += "---\n\n"
-        return markdown_text
-    except:
-        return ''
-# Run the application
 if __name__ == "__main__":
-    main()

 from bs4 import BeautifulSoup
 from collections import deque
 from dotenv import load_dotenv
+from gradio_client import Client, handle_file
 from huggingface_hub import InferenceClient
 from io import BytesIO
 from moviepy.editor import VideoFileClip
 from urllib.parse import quote
 from xml.etree import ElementTree as ET
 from openai import OpenAI
+# 1. 🚲BikeAI🏆 Configuration and Setup
+Site_Name = '🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI'
+title = "🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI"
+helpURL = 'https://huggingface.co/awacke1'
+bugURL = 'https://huggingface.co/spaces/awacke1'
+icons = '🚲🏆'
 st.set_page_config(
     page_title=title,
     page_icon=icons,
     }
 )
+# 2. 🚲BikeAI🏆 Load environment variables and initialize clients
 load_dotenv()
 # OpenAI setup
     organization=os.getenv('OPENAI_ORG_ID')
 )
+# 3.🚲BikeAI🏆 Claude setup
 anthropic_key = os.getenv("ANTHROPIC_API_KEY_3")
 if anthropic_key == None:
     anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
 claude_client = anthropic.Anthropic(api_key=anthropic_key)
+# 4.🚲BikeAI🏆 Initialize session states
 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 = ""
+# 5. 🚲BikeAI🏆 HuggingFace AI setup
+API_URL = os.getenv('API_URL')
+HF_KEY = os.getenv('HF_KEY')
+MODEL1 = "meta-llama/Llama-2-7b-chat-hf"
+MODEL2 = "openai/whisper-small.en"
+headers = {
+    "Authorization": f"Bearer {HF_KEY}",
+    "Content-Type": "application/json"
+}
+# 6. 🚲BikeAI🏆 Custom CSS
+st.markdown("""
+<style>
+    .main {
+        background: linear-gradient(to right, #1a1a1a, #2d2d2d);
+        color: #ffffff;
+    }
+    .stMarkdown {
+        font-family: 'Helvetica Neue', sans-serif;
+    }
+    .category-header {
+        background: linear-gradient(45deg, #2b5876, #4e4376);
+        padding: 20px;
+        border-radius: 10px;
+        margin: 10px 0;
+    }
+    .scene-card {
+        background: rgba(0,0,0,0.3);
+        padding: 15px;
+        border-radius: 8px;
+        margin: 10px 0;
+        border: 1px solid rgba(255,255,255,0.1);
+    }
+    .media-gallery {
+        display: grid;
+        gap: 1rem;
+        padding: 1rem;
+    }
+    .bike-card {
+        background: rgba(255,255,255,0.05);
+        border-radius: 10px;
+        padding: 15px;
+        transition: transform 0.3s;
+    }
+    .bike-card:hover {
+        transform: scale(1.02);
+    }
+</style>
+""", unsafe_allow_html=True)
+# 7. Helper Functions
+def generate_filename(prompt, file_type):
+    """Generate a safe filename using the prompt and file type."""
+    central = pytz.timezone('US/Central')
+    safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
+    replaced_prompt = re.sub(r'[<>:"/\\|?*\n]', ' ', prompt)
+    safe_prompt = re.sub(r'\s+', ' ', replaced_prompt).strip()[:230]
+    return f"{safe_date_time}_{safe_prompt}.{file_type}"
+# 8. Function to create and save a file (and avoid the black hole of lost data 🕳)
+def create_file(filename, prompt, response, should_save=True):
+    if not should_save:
+        return
+    with open(filename, 'w', encoding='utf-8') as file:
+        file.write(prompt + "\n\n" + response)
+def create_and_save_file(content, file_type="md", prompt=None, is_image=False, should_save=True):
+    """Create and save file with proper handling of different types."""
+    if not should_save:
+        return None
+    filename = generate_filename(prompt if prompt else content, file_type)
+    with open(filename, "w", encoding="utf-8") as f:
+        if is_image:
+            f.write(content)
+        else:
+            f.write(prompt + "\n\n" + content if prompt else content)
+    return filename
+def get_download_link(file_path):
+    """Create download link for file."""
+    with open(file_path, "rb") as file:
+        contents = file.read()
+    b64 = base64.b64encode(contents).decode()
+    return f'<a href="data:file/txt;base64,{b64}" download="{os.path.basename(file_path)}">Download {os.path.basename(file_path)}📂</a>'
+@st.cache_resource
+def SpeechSynthesis(result):
+    """HTML5 Speech Synthesis."""
+    documentHTML5 = f'''
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Read It Aloud</title>
+        <script type="text/javascript">
+            function readAloud() {{
+                const text = document.getElementById("textArea").value;
+                const speech = new SpeechSynthesisUtterance(text);
+                window.speechSynthesis.speak(speech);
+            }}
+        </script>
+    </head>
+    <body>
+        <h1>🔊 Read It Aloud</h1>
+        <textarea id="textArea" rows="10" cols="80">{result}</textarea>
+        <br>
+        <button onclick="readAloud()">🔊 Read Aloud</button>
+    </body>
+    </html>
+    '''
+    components.html(documentHTML5, width=1280, height=300)
+# Media Processing Functions
+def process_image(image_input, user_prompt):
+    """Process image with GPT-4o vision."""
+    if isinstance(image_input, str):
+        with open(image_input, "rb") as image_file:
+            image_input = image_file.read()
+    base64_image = base64.b64encode(image_input).decode("utf-8")
+    response = openai_client.chat.completions.create(
+        model=st.session_state["openai_model"],
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant that responds in Markdown."},
+            {"role": "user", "content": [
+                {"type": "text", "text": user_prompt},
+                {"type": "image_url", "image_url": {
+                    "url": f"data:image/png;base64,{base64_image}"
+                }}
+            ]}
+        ],
+        temperature=0.0,
+    )
+    return response.choices[0].message.content
+def process_audio(audio_input, text_input=''):
+    """Process audio with Whisper and GPT."""
+    if isinstance(audio_input, str):
+        with open(audio_input, "rb") as file:
+            audio_input = file.read()
+    transcription = openai_client.audio.transcriptions.create(
+        model="whisper-1",
+        file=audio_input,
+    )
+    st.session_state.messages.append({"role": "user", "content": transcription.text})
+    with st.chat_message("assistant"):
+        st.markdown(transcription.text)
+        SpeechSynthesis(transcription.text)
+        filename = generate_filename(transcription.text, "wav")
+        create_and_save_file(audio_input, "wav", transcription.text, True)
+def process_video(video_path, seconds_per_frame=1):
+    """Process video files for frame extraction and audio."""
+    base64Frames = []
+    video = cv2.VideoCapture(video_path)
+    total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = video.get(cv2.CAP_PROP_FPS)
+    frames_to_skip = int(fps * seconds_per_frame)
+    for frame_idx in range(0, total_frames, frames_to_skip):
+        video.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+        success, frame = video.read()
+        if not success:
+            break
+        _, buffer = cv2.imencode(".jpg", frame)
+        base64Frames.append(base64.b64encode(buffer).decode("utf-8"))
+    video.release()
+    # Extract audio
+    base_video_path = os.path.splitext(video_path)[0]
+    audio_path = f"{base_video_path}.mp3"
+    try:
+        video_clip = VideoFileClip(video_path)
+        video_clip.audio.write_audiofile(audio_path)
+        video_clip.close()
+    except:
+        st.warning("No audio track found in video")
+        audio_path = None
+    return base64Frames, audio_path
+def process_video_with_gpt(video_input, user_prompt):
+    """Process video with GPT-4o vision."""
+    base64Frames, audio_path = process_video(video_input)
+    response = openai_client.chat.completions.create(
+        model=st.session_state["openai_model"],
+        messages=[
+            {"role": "system", "content": "Analyze the video frames and provide a detailed description."},
+            {"role": "user", "content": [
+                {"type": "text", "text": user_prompt},
+                *[{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{frame}"}}
+                  for frame in base64Frames]
+            ]}
+        ]
+    )
+    return response.choices[0].message.content
+def extract_urls(text):
+    try:
+        date_pattern = re.compile(r'### (\d{2} \w{3} \d{4})')
+        abs_link_pattern = re.compile(r'\[(.*?)\]\((https://arxiv\.org/abs/\d+\.\d+)\)')
+        pdf_link_pattern = re.compile(r'\[⬇️\]\((https://arxiv\.org/pdf/\d+\.\d+)\)')
+        title_pattern = re.compile(r'### \d{2} \w{3} \d{4} \| \[(.*?)\]')
+        date_matches = date_pattern.findall(text)
+        abs_link_matches = abs_link_pattern.findall(text)
+        pdf_link_matches = pdf_link_pattern.findall(text)
+        title_matches = title_pattern.findall(text)
+        # markdown with the extracted fields
+        markdown_text = ""
+        for i in range(len(date_matches)):
+            date = date_matches[i]
+            title = title_matches[i]
+            abs_link = abs_link_matches[i][1]
+            pdf_link = pdf_link_matches[i]
+            markdown_text += f"**Date:** {date}\n\n"
+            markdown_text += f"**Title:** {title}\n\n"
+            markdown_text += f"**Abstract Link:** [{abs_link}]({abs_link})\n\n"
+            markdown_text += f"**PDF Link:** [{pdf_link}]({pdf_link})\n\n"
+            markdown_text += "---\n\n"
+        return markdown_text
+    except:
+        st.write('.')
+        return ''
+def search_arxiv(query):
+    st.write("Performing AI Lookup...")
+    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
+    result1 = client.predict(
+        prompt=query,
+        llm_model_picked="mistralai/Mixtral-8x7B-Instruct-v0.1",
+        stream_outputs=True,
+        api_name="/ask_llm"
+    )
+    st.markdown("### Mixtral-8x7B-Instruct-v0.1 Result")
+    st.markdown(result1)
+    result2 = client.predict(
+        prompt=query,
+        llm_model_picked="mistralai/Mistral-7B-Instruct-v0.2",
+        stream_outputs=True,
+        api_name="/ask_llm"
+    )
+    st.markdown("### Mistral-7B-Instruct-v0.2 Result")
+    st.markdown(result2)
+    combined_result = f"{result1}\n\n{result2}"
+    return combined_result
+    #return responseall
+# Function to generate a filename based on prompt and time (because names matter 🕒)
+def generate_filename(prompt, file_type):
+    central = pytz.timezone('US/Central')
+    safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
+    safe_prompt = re.sub(r'\W+', '_', prompt)[:90]
+    return f"{safe_date_time}_{safe_prompt}.{file_type}"
+# Function to create and save a file (and avoid the black hole of lost data 🕳)
+def create_file(filename, prompt, response):
+    with open(filename, 'w', encoding='utf-8') as file:
+        file.write(prompt + "\n\n" + response)
+def perform_ai_lookup(query):
+    start_time = time.strftime("%Y-%m-%d %H:%M:%S")
+    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
+    response1 = client.predict(
+        query,
+        20,
+        "Semantic Search",
+        "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        api_name="/update_with_rag_md"
+    )
+    Question = '### 🔎 ' + query + '\r\n'  # Format for markdown display with links
+    References =  response1[0]
+    ReferenceLinks = extract_urls(References)
+    RunSecondQuery = True
+    results=''
+    if RunSecondQuery:
+        # Search 2 - Retrieve the Summary with Papers Context and Original Query
+        response2 = client.predict(
+            query,
+            "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            True,
+            api_name="/ask_llm"
+        )
+        if len(response2) > 10:
+            Answer = response2
+            SpeechSynthesis(Answer)
+            # Restructure results to follow format of Question, Answer, References, ReferenceLinks
+            results = Question + '\r\n' + Answer + '\r\n' + References + '\r\n' + ReferenceLinks
+            st.markdown(results)
+    st.write('🔍Run of Multi-Agent System Paper Summary Spec is Complete')
+    end_time = time.strftime("%Y-%m-%d %H:%M:%S")
+    start_timestamp = time.mktime(time.strptime(start_time, "%Y-%m-%d %H:%M:%S"))
+    end_timestamp = time.mktime(time.strptime(end_time, "%Y-%m-%d %H:%M:%S"))
+    elapsed_seconds = end_timestamp - start_timestamp
+    st.write(f"Start time: {start_time}")
+    st.write(f"Finish time: {end_time}")
+    st.write(f"Elapsed time: {elapsed_seconds:.2f} seconds")
+    filename = generate_filename(query, "md")
+    create_file(filename, query, results)
+    return results
+# Chat Processing Functions
 def process_with_gpt(text_input):
+    """Process text with GPT-4o."""
     if text_input:
         st.session_state.messages.append({"role": "user", "content": text_input})
                 stream=False
             )
             return_text = completion.choices[0].message.content
+            st.write("GPT-4o: " + return_text)
+            #filename = generate_filename(text_input, "md")
+            filename = generate_filename("GPT-4o: " + return_text, "md")
             create_file(filename, text_input, return_text)
             st.session_state.messages.append({"role": "assistant", "content": return_text})
             return return_text
 def process_with_claude(text_input):
     """Process text with Claude."""
     if text_input:
         with st.chat_message("user"):
             st.markdown(text_input)
             response_text = response.content[0].text
             st.write("Claude: " + response_text)
+            #filename = generate_filename(text_input, "md")
             filename = generate_filename("Claude: " + response_text, "md")
             create_file(filename, text_input, response_text)
             })
             return response_text
+# File Management Functions
+def load_file(file_name):
+    """Load file content."""
+    with open(file_name, "r", encoding='utf-8') as file:
+        content = file.read()
+    return content
+def create_zip_of_files(files):
+    """Create zip archive of files."""
+    zip_name = "all_files.zip"
+    with zipfile.ZipFile(zip_name, 'w') as zipf:
+        for file in files:
+            zipf.write(file)
+    return zip_name
+def get_media_html(media_path, media_type="video", width="100%"):
+    """Generate HTML for media player."""
+    media_data = base64.b64encode(open(media_path, 'rb').read()).decode()
+    if media_type == "video":
+        return f'''
+        <video width="{width}" controls autoplay muted loop>
+            <source src="data:video/mp4;base64,{media_data}" type="video/mp4">
+            Your browser does not support the video tag.
+        </video>
+        '''
+    else:  # audio
+        return f'''
+        <audio controls style="width: {width};">
+            <source src="data:audio/mpeg;base64,{media_data}" type="audio/mpeg">
+            Your browser does not support the audio element.
+        </audio>
+        '''
+def create_media_gallery():
+    """Create the media gallery interface."""
+    st.header("🎬 Media Gallery")
+    tabs = st.tabs(["🖼️ Images", "🎵 Audio", "🎥 Video"])
+    with tabs[0]:
+        image_files = glob.glob("*.png") + glob.glob("*.jpg")
+        if image_files:
+            num_cols = st.slider("Number of columns", 1, 5, 3)
+            cols = st.columns(num_cols)
+            for idx, image_file in enumerate(image_files):
+                with cols[idx % num_cols]:
+                    img = Image.open(image_file)
+                    st.image(img, use_container_width=True)
+                    # Add GPT vision analysis option
+                    if st.button(f"Analyze {os.path.basename(image_file)}"):
+                        analysis = process_image(image_file,
+                                              "Describe this image in detail and identify key elements.")
+                        st.markdown(analysis)
+    with tabs[1]:
+        audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
+        for audio_file in audio_files:
+            with st.expander(f"🎵 {os.path.basename(audio_file)}"):
+                st.markdown(get_media_html(audio_file, "audio"), unsafe_allow_html=True)
+                if st.button(f"Transcribe {os.path.basename(audio_file)}"):
+                    with open(audio_file, "rb") as f:
+                        transcription = process_audio(f)
+                        st.write(transcription)
+    with tabs[2]:
+        video_files = glob.glob("*.mp4")
+        for video_file in video_files:
+            with st.expander(f"🎥 {os.path.basename(video_file)}"):
+                st.markdown(get_media_html(video_file, "video"), unsafe_allow_html=True)
+                if st.button(f"Analyze {os.path.basename(video_file)}"):
+                    analysis = process_video_with_gpt(video_file,
+                                                    "Describe what's happening in this video.")
+                    st.markdown(analysis)
+def display_file_manager():
+    """Display file management sidebar with guaranteed unique button keys."""
+    st.sidebar.title("📁 File Management")
+    all_files = glob.glob("*.md")
+    all_files.sort(reverse=True)
+    if st.sidebar.button("🗑 Delete All", key="delete_all_files_button"):
+        for file in all_files:
+            os.remove(file)
+        st.rerun()
+    if st.sidebar.button("⬇️ Download All", key="download_all_files_button"):
+        zip_file = create_zip_of_files(all_files)
+        st.sidebar.markdown(get_download_link(zip_file), unsafe_allow_html=True)
+    # Create unique keys using file attributes
+    for idx, file in enumerate(all_files):
+        # Get file stats for unique identification
+        file_stat = os.stat(file)
+        unique_id = f"{idx}_{file_stat.st_size}_{file_stat.st_mtime}"
+        col1, col2, col3, col4 = st.sidebar.columns([1,3,1,1])
+        with col1:
+            if st.button("🌐", key=f"view_{unique_id}"):
+                st.session_state.current_file = file
+                st.session_state.file_content = load_file(file)
+        with col2:
+            st.markdown(get_download_link(file), unsafe_allow_html=True)
+        with col3:
+            if st.button("📂", key=f"edit_{unique_id}"):
+                st.session_state.current_file = file
+                st.session_state.file_content = load_file(file)
+        with col4:
+            if st.button("🗑", key=f"delete_{unique_id}"):
+                os.remove(file)
+                st.rerun()
+# Speech Recognition HTML Component
+speech_recognition_html = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Continuous Speech Demo</title>
+    <style>
+        body {
+            font-family: sans-serif;
+            padding: 20px;
+            max-width: 800px;
+            margin: 0 auto;
+        }
+        button {
+            padding: 10px 20px;
+            margin: 10px 5px;
+            font-size: 16px;
+        }
+        #status {
+            margin: 10px 0;
+            padding: 10px;
+            background: #e8f5e9;
+            border-radius: 4px;
+        }
+        #output {
+            white-space: pre-wrap;
+            padding: 15px;
+            background: #f5f5f5;
+            border-radius: 4px;
+            margin: 10px 0;
+            min-height: 100px;
+            max-height: 400px;
+            overflow-y: auto;
+        }
+        .controls {
+            margin: 10px 0;
+        }
+    </style>
+</head>
+<body>
+    <div class="controls">
+        <button id="start">Start Listening</button>
+        <button id="stop" disabled>Stop Listening</button>
+        <button id="clear">Clear Text</button>
+    </div>
+    <div id="status">Ready</div>
+    <div id="output"></div>
+    <script>
+        if (!('webkitSpeechRecognition' in window)) {
+            alert('Speech recognition not supported');
+        } else {
+            const recognition = new webkitSpeechRecognition();
+            const startButton = document.getElementById('start');
+            const stopButton = document.getElementById('stop');
+            const clearButton = document.getElementById('clear');
+            const status = document.getElementById('status');
+            const output = document.getElementById('output');
+            let fullTranscript = '';
+            let lastUpdateTime = Date.now();
+            // Configure recognition
+            recognition.continuous = true;
+            recognition.interimResults = true;
+            // Function to start recognition
+            const startRecognition = () => {
+                try {
+                    recognition.start();
+                    status.textContent = 'Listening...';
+                    startButton.disabled = true;
+                    stopButton.disabled = false;
+                } catch (e) {
+                    console.error(e);
+                    status.textContent = 'Error: ' + e.message;
+                }
+            };
+            // Auto-start on load
+            window.addEventListener('load', () => {
+                setTimeout(startRecognition, 1000);
+            });
+            startButton.onclick = startRecognition;
+            stopButton.onclick = () => {
+                recognition.stop();
+                status.textContent = 'Stopped';
+                startButton.disabled = false;
+                stopButton.disabled = true;
+            };
+            clearButton.onclick = () => {
+                fullTranscript = '';
+                output.textContent = '';
+                window.parent.postMessage({
+                    type: 'clear_transcript',
+                }, '*');
+            };
+            recognition.onresult = (event) => {
+                let interimTranscript = '';
+                let finalTranscript = '';
+                for (let i = event.resultIndex; i < event.results.length; i++) {
+                    const transcript = event.results[i][0].transcript;
+                    if (event.results[i].isFinal) {
+                        finalTranscript += transcript + '\\n';
+                    } else {
+                        interimTranscript += transcript;
+                    }
+                }
+                if (finalTranscript || (Date.now() - lastUpdateTime > 5000)) {
+                    if (finalTranscript) {
+                        fullTranscript += finalTranscript;
+                        // Send to Streamlit
+                        window.parent.postMessage({
+                            type: 'final_transcript',
+                            text: finalTranscript
+                        }, '*');
+                    }
+                    lastUpdateTime = Date.now();
+                }
+                output.textContent = fullTranscript + (interimTranscript ? '... ' + interimTranscript : '');
+                output.scrollTop = output.scrollHeight;
+            };
+            recognition.onend = () => {
+                if (!stopButton.disabled) {
+                    try {
+                        recognition.start();
+                        console.log('Restarted recognition');
+                    } catch (e) {
+                        console.error('Failed to restart recognition:', e);
+                        status.textContent = 'Error restarting: ' + e.message;
+                        startButton.disabled = false;
+                        stopButton.disabled = true;
+                    }
+                }
+            };
+            recognition.onerror = (event) => {
+                console.error('Recognition error:', event.error);
+                status.textContent = 'Error: ' + event.error;
+                if (event.error === 'not-allowed' || event.error === 'service-not-allowed') {
+                    startButton.disabled = false;
+                    stopButton.disabled = true;
+                }
+            };
+        }
+    </script>
+</body>
+</html>
+"""
+# Helper Functions
+def generate_filename(prompt, file_type):
+    central = pytz.timezone('US/Central')
+    safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
+    replaced_prompt = re.sub(r'[<>:"/\\|?*\n]', ' ', prompt)
+    safe_prompt = re.sub(r'\s+', ' ', replaced_prompt).strip()[:230]
+    return f"{safe_date_time}_{safe_prompt}.{file_type}"
+# File Management Functions
+def load_file(file_name):
+    """Load file content."""
+    with open(file_name, "r", encoding='utf-8') as file:
+        content = file.read()
+    return content
+def create_zip_of_files(files):
+    """Create zip archive of files."""
+    zip_name = "all_files.zip"
+    with zipfile.ZipFile(zip_name, 'w') as zipf:
+        for file in files:
+            zipf.write(file)
+    return zip_name
+def get_download_link(file):
+    """Create download link for file."""
+    with open(file, "rb") as f:
+        contents = f.read()
+    b64 = base64.b64encode(contents).decode()
+    return f'<a href="data:file/txt;base64,{b64}" download="{os.path.basename(file)}">Download {os.path.basename(file)}📂</a>'
+def display_file_manager():
+    """Display file management sidebar."""
+    st.sidebar.title("📁 File Management")
+    all_files = glob.glob("*.md")
+    all_files.sort(reverse=True)
+    if st.sidebar.button("🗑 Delete All"):
+        for file in all_files:
+            os.remove(file)
+        st.rerun()
+    if st.sidebar.button("⬇️ Download All"):
+        zip_file = create_zip_of_files(all_files)
+        st.sidebar.markdown(get_download_link(zip_file), unsafe_allow_html=True)
+    for file in all_files:
+        col1, col2, col3, col4 = st.sidebar.columns([1,3,1,1])
+        with col1:
+            if st.button("🌐", key="view_"+file):
+                st.session_state.current_file = file
+                st.session_state.file_content = load_file(file)
+        with col2:
+            st.markdown(get_download_link(file), unsafe_allow_html=True)
+        with col3:
+            if st.button("📂", key="edit_"+file):
+                st.session_state.current_file = file
+                st.session_state.file_content = load_file(file)
+        with col4:
+            if st.button("🗑", key="delete_"+file):
+                os.remove(file)
+                st.rerun()
+def create_media_gallery():
+    """Create the media gallery interface."""
+    st.header("🎬 Media Gallery")
+    tabs = st.tabs(["🖼️ Images", "🎵 Audio", "🎥 Video"])
+    with tabs[0]:
+        image_files = glob.glob("*.png") + glob.glob("*.jpg")
+        if image_files:
+            num_cols = st.slider("Number of columns", 1, 5, 3)
+            cols = st.columns(num_cols)
+            for idx, image_file in enumerate(image_files):
+                with cols[idx % num_cols]:
+                    img = Image.open(image_file)
+                    st.image(img, use_container_width=True)
+                    # Add GPT vision analysis option
+                    if st.button(f"Analyze {os.path.basename(image_file)}"):
+                        analysis = process_image(image_file,
+                                              "Describe this image in detail and identify key elements.")
+                        st.markdown(analysis)
+    with tabs[1]:
+        audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
+        for audio_file in audio_files:
+            with st.expander(f"🎵 {os.path.basename(audio_file)}"):
+                st.markdown(get_media_html(audio_file, "audio"), unsafe_allow_html=True)
+                if st.button(f"Transcribe {os.path.basename(audio_file)}"):
+                    with open(audio_file, "rb") as f:
+                        transcription = process_audio(f)
+                        st.write(transcription)
+    with tabs[2]:
+        video_files = glob.glob("*.mp4")
+        for video_file in video_files:
+            with st.expander(f"🎥 {os.path.basename(video_file)}"):
+                st.markdown(get_media_html(video_file, "video"), unsafe_allow_html=True)
+                if st.button(f"Analyze {os.path.basename(video_file)}"):
+                    analysis = process_video_with_gpt(video_file,
+                                                    "Describe what's happening in this video.")
+                    st.markdown(analysis)
+def get_media_html(media_path, media_type="video", width="100%"):
+    """Generate HTML for media player."""
+    media_data = base64.b64encode(open(media_path, 'rb').read()).decode()
+    if media_type == "video":
+        return f'''
+        <video width="{width}" controls autoplay muted loop>
+            <source src="data:video/mp4;base64,{media_data}" type="video/mp4">
+            Your browser does not support the video tag.
+        </video>
+        '''
+    else:  # audio
+        return f'''
+        <audio controls style="width: {width};">
+            <source src="data:audio/mpeg;base64,{media_data}" type="audio/mpeg">
+            Your browser does not support the audio element.
+        </audio>
+        '''
+@st.cache_resource
+def set_transcript(text):
+    """Set transcript in session state."""
+    st.session_state.voice_transcript = text
 def main():
     st.sidebar.markdown("### 🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI")
+    # Main navigation
     tab_main = st.radio("Choose Action:",
                         ["🎤 Voice Input", "💬 Chat", "📸 Media Gallery", "🔍 Search ArXiv", "📝 File Editor"],
                         horizontal=True)
     if tab_main == "🎤 Voice Input":
         st.subheader("Voice Recognition")
         # Display speech recognition component
+        speech_component = st.components.v1.html(speech_recognition_html, height=400)
+        #Experiment:   Use `st.session_state` to store the transcript
+        if 'voice_transcript' not in st.session_state:
+            st.session_state.voice_transcript = ""
+        # JavaScript and Streamlit integration to capture transcript
+        st.components.v1.html("""
+        <script>
+            window.addEventListener('message', (event) => {
+                if (event.data.type === 'final_transcript') {
+                    const transcript = event.data.text;
+                    // Update Streamlit session state with the transcript
+                    Streamlit.setComponentValue(transcript);
+                }
+            });
+        </script>
         """, height=0)
+        # Display the transcript in a Streamlit text area
+        st.markdown("### Processed Voice Input:")
+        st.text_area("Voice Transcript", st.session_state.voice_transcript, height=100)
+        # Add functionality to process the transcript
+        if st.button("Process Transcript"):
+            st.subheader("AI Response to Transcript")
+            gpt_response = process_with_gpt(st.session_state.voice_transcript)
+            st.markdown(gpt_response)
+        # Option to clear the transcript
+        if st.button("Clear Transcript"):
+            st.session_state.voice_transcript = ""
+        #st.markdown("### Processed Voice Input:")
+        #st.text_area("Voice Transcript", st.session_state.voice_transcript, height=100)
+        # Buttons to process the transcript
+        if st.button("Search with GPT"):
+            st.subheader("GPT-4o Response")
+            gpt_response = process_with_gpt(st.session_state.voice_transcript)
+            st.markdown(gpt_response)
+        if st.button("Search with Claude"):
+            st.subheader("Claude Response")
+            claude_response = process_with_claude(st.session_state.voice_transcript)
+            st.markdown(claude_response)
+        if st.button("Search ArXiv"):
+            st.subheader("ArXiv Search Results")
+            arxiv_results = perform_ai_lookup(st.session_state.voice_transcript)
+            st.markdown(arxiv_results)
+        # Clear transcript button
+        #if st.button("Clear Transcript"):
+        #    st.session_state.voice_transcript = ""
+        # Handle speech recognition output
+        if speech_component:
+            try:
+                data = speech_component
+                if isinstance(data, dict):
+                    if data.get('type') == 'final_transcript':
+                        text = data.get('text', '').strip()
+                        if text:
+                            st.session_state.last_voice_input = text
+                            # Process voice input with AI
+                            st.subheader("AI Response to Voice Input:")
+                            col1, col2, col3 = st.columns(3)
+                            with col2:
+                                st.write("Claude-3.5 Sonnet:")
+                                try:
+                                    claude_response = process_with_claude(text)
+                                except:
+                                    st.write('Claude 3.5 Sonnet out of tokens.')
+                            with col1:
+                                st.write("GPT-4o Omni:")
+                                try:
+                                    gpt_response = process_with_gpt(text)
+                                except:
+                                    st.write('GPT 4o out of tokens')
+                            with col3:
+                                st.write("Arxiv and Mistral Research:")
+                                with st.spinner("Searching ArXiv..."):
+                                    results = perform_ai_lookup(text)
+                                    st.markdown(results)
+                    elif data.get('type') == 'clear_transcript':
+                        st.session_state.last_voice_input = ""
+                        st.experimental_rerun()
+            except Exception as e:
+                st.error(f"Error processing voice input: {e}")
+        # Display last voice input
+        if st.session_state.last_voice_input:
+            st.text_area("Last Voice Input:", st.session_state.last_voice_input, height=100)
+    if tab_main == "💬 Chat":
         # Model Selection
         model_choice = st.sidebar.radio(
             "Choose AI Model:",
+            ["GPT-4o", "Claude-3", "GPT+Claude+Arxiv"]
         )
         # Chat Interface
         if st.button("Send 📨"):
             if user_input:
+                if model_choice == "GPT-4o":
                     gpt_response = process_with_gpt(user_input)
                 elif model_choice == "Claude-3":
                     claude_response = process_with_claude(user_input)
+                else:  # Both
                     col1, col2, col3 = st.columns(3)
                     with col2:
+                        st.subheader("Claude-3.5 Sonnet:")
                         try:
                             claude_response = process_with_claude(user_input)
                         except:
+                            st.write('Claude 3.5 Sonnet out of tokens.')
+                    with col1:
+                        st.subheader("GPT-4o Omni:")
+                        try:
+                            gpt_response = process_with_gpt(user_input)
+                        except:
+                            st.write('GPT 4o out of tokens')
                     with col3:
+                        st.subheader("Arxiv and Mistral Research:")
                         with st.spinner("Searching ArXiv..."):
+                            #results = search_arxiv(user_input)
                             results = perform_ai_lookup(user_input)
                             st.markdown(results)
         # Display Chat History
         st.subheader("Chat History 📜")
+        tab1, tab2 = st.tabs(["Claude History", "GPT-4o History"])
         with tab1:
             for chat in st.session_state.chat_history:
         query = st.text_input("Enter your research query:")
         if query:
             with st.spinner("Searching ArXiv..."):
+                results = search_arxiv(query)
                 st.markdown(results)
     elif tab_main == "📝 File Editor":
                 with open(st.session_state.current_file, 'w', encoding='utf-8') as file:
                     file.write(new_content)
                 st.success("File updated successfully!")
     # Always show file manager in sidebar
     display_file_manager()
 if __name__ == "__main__":
+    main()