Update app.py

app.py

@@ -1,21 +1,29 @@
-import gradio as gr
-import groq
+# Standard library imports
 import os
 import tempfile
 import uuid
-import yfinance as yf
-import pandas as pd
-import plotly.graph_objects as go
-from dotenv import load_dotenv
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.vectorstores import FAISS
-from langchain.embeddings import HuggingFaceEmbeddings
-import fitz  # PyMuPDF
 import base64
-from PIL import Image
 import io
-import requests
 import json
+import re
+from datetime import datetime, timedelta
+
+# Third-party imports
+import gradio as gr
+import groq
+import numpy as np
+import requests
+import fitz  # PyMuPDF
+from PIL import Image
+from dotenv import load_dotenv
+from transformers import AutoProcessor, AutoModelForVision2Seq
+import torch
+import arxiv
+
+# LangChain imports
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 # Load environment variables
 load_dotenv()
@@ -23,19 +31,32 @@ client = groq.Client(api_key=os.getenv("GROQ_LEGAL_API_KEY"))
 embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
 # Directory to store FAISS indexes
-FAISS_INDEX_DIR = "faiss_indexes_finance"
+FAISS_INDEX_DIR = "faiss_indexes_academic"
 if not os.path.exists(FAISS_INDEX_DIR):
     os.makedirs(FAISS_INDEX_DIR)
 
 # Dictionary to store user-specific vectorstores
 user_vectorstores = {}
 
-# Custom CSS for Finance theme
+# Load SmolDocling model for image analysis
+def load_docling_model():
+    try:
+        processor = AutoProcessor.from_pretrained("ds4sd/SmolDocling-256M-preview")
+        model = AutoModelForVision2Seq.from_pretrained("ds4sd/SmolDocling-256M-preview")
+        return processor, model
+    except Exception as e:
+        print(f"Error loading SmolDocling model: {e}")
+        return None, None
+
+# Initialize SmolDocling model
+docling_processor, docling_model = load_docling_model()
+
+# Custom CSS for Academic theme
 custom_css = """
 :root {
-    --primary-color: #FFD700;  /* Gold */
-    --secondary-color: #008000;  /* Dark Green */
-    --light-background: #F0FFF0;  /* Honeydew */
+    --primary-color: #003366;  /* Deep Blue */
+    --secondary-color: #000080;  /* Navy */
+    --light-background: #F5F5F5;  /* Light Gray */
     --dark-text: #333333;
     --white: #FFFFFF;
     --border-color: #E5E7EB;
@@ -46,7 +67,7 @@ body { background-color: var(--light-background); font-family: 'Inter', sans-ser
 .header-title { color: var(--secondary-color); font-size: 1.8rem; font-weight: 700; text-align: center; }
 .header-subtitle { color: var(--dark-text); font-size: 1rem; text-align: center; margin-top: 5px; }
 .chat-container { border-radius: 12px !important; box-shadow: 0 4px 6px rgba(0,0,0,0.1) !important; background-color: var(--white) !important; border: 1px solid var(--border-color) !important; min-height: 500px; }
-.message-user { background-color: var(--primary-color) !important; color: var(--dark-text) !important; border-radius: 18px 18px 4px 18px !important; padding: 12px 16px !important; margin-left: auto !important; max-width: 80% !important; }
+.message-user { background-color: var(--primary-color) !important; color: var(--white) !important; border-radius: 18px 18px 4px 18px !important; padding: 12px 16px !important; margin-left: auto !important; max-width: 80% !important; }
 .message-bot { background-color: #F0F0F0 !important; color: var(--dark-text) !important; border-radius: 18px 18px 18px 4px !important; padding: 12px 16px !important; margin-right: auto !important; max-width: 80% !important; }
 .input-area { background-color: var(--white) !important; border-top: 1px solid var(--border-color) !important; padding: 12px !important; border-radius: 0 0 12px 12px !important; }
 .input-box { border: 1px solid var(--border-color) !important; border-radius: 24px !important; padding: 12px 16px !important; box-shadow: 0 2px 4px rgba(0,0,0,0.05) !important; }
@@ -54,10 +75,20 @@ body { background-color: var(--light-background); font-family: 'Inter', sans-ser
 .clear-btn { background-color: #F0F0F0 !important; border: 1px solid var(--border-color) !important; border-radius: 24px !important; color: var(--dark-text) !important; padding: 8px 16px !important; font-weight: 500 !important; }
 .pdf-viewer-container { border-radius: 12px !important; box-shadow: 0 4px 6px rgba(0,0,0,0.1) !important; background-color: var(--white) !important; border: 1px solid var(--border-color) !important; padding: 20px; }
 .pdf-viewer-image { max-width: 100%; height: auto; border: 1px solid var(--border-color); border-radius: 12px; box-shadow: 0 2px 4px rgba(0,0,0,0.05); }
-.stats-box { background-color: #E6F2E6; padding: 10px; border-radius: 8px; margin-top: 10px; }
+.stats-box { background-color: #E6E6FA; padding: 10px; border-radius: 8px; margin-top: 10px; }
 .tool-container { background-color: var(--white); border-radius: 12px; box-shadow: 0 4px 6px rgba(0,0,0,0.1); padding: 15px; margin-bottom: 20px; }
-.tool-title { color: var(--secondary-color); font-size: 1.2rem; font-weight: 600; margin-bottom: 10px; }
-.chart-container { height: 400px; width: 100%; border-radius: 8px; overflow: hidden; }
+.paper-card { border-left: 3px solid var(--primary-color); padding: 10px; margin: 15px 0; background-color: #F8F9FA; border-radius: 8px; }
+.paper-title { font-weight: bold; color: var(--primary-color); font-size: 1.1rem; margin-bottom: 5px; }
+.paper-authors { color: var(--dark-text); font-size: 0.9rem; margin-bottom: 5px; }
+.paper-abstract { font-size: 0.95rem; margin: 10px 0; }
+.paper-meta { color: #666; font-size: 0.85rem; display: flex; justify-content: space-between; }
+.citation-box { background-color: #F0F0F8; border: 1px solid #D1D5DB; border-radius: 8px; padding: 15px; margin: 10px 0; font-family: monospace; white-space: pre-wrap; }
+.toggle-container { display: flex; align-items: center; margin-bottom: 15px; }
+.toggle-label { margin-right: 10px; font-weight: 500; }
+.search-toggle { margin-left: 5px; }
+.voice-btn { background-color: var(--primary-color) !important; border-radius: 50% !important; width: 44px !important; height: 44px !important; display: flex !important; align-items: center !important; justify-content: center !important; color: var(--white) !important; box-shadow: 0 2px 5px rgba(0,0,0,0.2) !important; }
+.speak-btn { background-color: var(--secondary-color) !important; border-radius: 24px !important; color: var(--white) !important; padding: 8px 16px !important; font-weight: 500 !important; margin-left: 10px !important; }
+.audio-controls { display: flex; align-items: center; margin-top: 10px; }
 """
 
 # Function to process PDF files (unchanged)
@@ -97,8 +128,80 @@ def process_pdf(pdf_file):
             os.unlink(pdf_path)
         return None, f"Error processing PDF: {str(e)}", {"page_images": [], "total_pages": 0, "total_words": 0}
 
-# Function to generate chatbot responses with Finance theme
-def generate_response(message, session_id, model_name, history):
+# Function to analyze image using SmolDocling
+def analyze_image(image_file):
+    if image_file is None:
+        return "No image uploaded. Please upload an image to analyze."
+    
+    if docling_processor is None or docling_model is None:
+        return "SmolDocling model not loaded. Please check your installation."
+    
+    try:
+        # Process the image - image_file is a filepath string from Gradio
+        image = Image.open(image_file)
+        
+        # Use the SmolDocling model
+        inputs = docling_processor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            outputs = docling_model.generate(
+                **inputs, 
+                max_new_tokens=512,
+                temperature=0.1,
+                do_sample=False
+            )
+        
+        # Decode the output
+        result = docling_processor.batch_decode(outputs, skip_special_tokens=True)[0]
+        
+        # Format the result for display with academic emphasis
+        analysis = f"## Academic Document Analysis Results\n\n{result}\n\n"
+        analysis += "### Research Applications\n\n"
+        analysis += "* This analysis can support academic research by identifying key information in document images.\n"
+        analysis += "* Consider using these results as preliminary observations that may require further scholarly verification.\n"
+        
+        return analysis
+    except Exception as e:
+        return f"Error analyzing image: {str(e)}"
+
+# Function for speech-to-text conversion
+def speech_to_text():
+    try:
+        r = sr.Recognizer()
+        with sr.Microphone() as source:
+            r.adjust_for_ambient_noise(source)
+            audio = r.listen(source)
+            text = r.recognize_google(audio)
+            return text
+    except sr.UnknownValueError:
+        return "Could not understand audio. Please try again."
+    except sr.RequestError as e:
+        return f"Error with speech recognition service: {e}"
+    except Exception as e:
+        return f"Error converting speech to text: {str(e)}"
+
+# Function for text-to-speech conversion
+def text_to_speech(text, history):
+    if not text or not history:
+        return None
+    
+    try:
+        # Get the last bot response
+        last_response = history[-1][1]
+        
+        # Convert text to speech
+        tts = gTTS(text=last_response, lang='en', slow=False)
+        
+        # Save to a temporary file
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+        tts.save(temp_file.name)
+        
+        return temp_file.name
+    except Exception as e:
+        print(f"Error in text-to-speech: {e}")
+        return None
+
+# Function to generate chatbot responses with Academic theme
+def generate_response(message, session_id, model_name, history, web_search_enabled=True):
     if not message:
         return history
     try:
@@ -109,28 +212,49 @@ def generate_response(message, session_id, model_name, history):
             if docs:
                 context = "\n\nRelevant information from uploaded PDF:\n" + "\n".join(f"- {doc.page_content}" for doc in docs)
         
-        # Check if it's a stock ticker query
-        if message.startswith("$") and len(message) > 1 and len(message) <= 6:
-            ticker = message[1:].upper()
-            try:
-                stock_data = get_stock_data(ticker)
-                response = f"**Stock Information for {ticker}**\n\n"
-                response += f"Current Price: ${stock_data['current_price']}\n"
-                response += f"52-Week High: ${stock_data['52wk_high']}\n"
-                response += f"Market Cap: ${stock_data['market_cap']:,}\n"
-                response += f"P/E Ratio: {stock_data['pe_ratio']}\n"
-                response += f"More data available in the Stock Analysis tab."
+        # Check if it's a special command for paper search and web search is enabled
+        if web_search_enabled and (message.lower().startswith("/paper ") or message.lower().startswith("/arxiv ")):
+            query = message.split(" ", 1)[1]
+            paper_results = search_arxiv(query)
+            if paper_results:
+                response = "**Academic Paper Search Results:**\n\n"
+                for paper in paper_results[:3]:  # Limit to top 3 results
+                    response += f"**{paper['title']}**\n"
+                    response += f"Authors: {paper['authors']}\n"
+                    response += f"Published: {paper['published']}\n"
+                    response += f"Summary: {paper['summary'][:250]}...\n"
+                    response += f"Link: {paper['url']}\n\n"
                 history.append((message, response))
                 return history
+            else:
+                history.append((message, "No paper results found for your query."))
+                return history
+        
+        # Check if it's a citation request and web search is enabled
+        citation_match = re.search(r'/cite\s+(.+)', message, re.IGNORECASE)
+        if web_search_enabled and citation_match:
+            search_term = citation_match.group(1).strip()
+            try:
+                paper = search_paper_by_title(search_term)
+                if paper:
+                    citations = generate_citations(paper)
+                    response = f"**Citation for '{paper['title']}':**\n\n"
+                    response += f"APA: {citations['apa']}\n\n"
+                    response += f"MLA: {citations['mla']}\n\n"
+                    response += f"Chicago: {citations['chicago']}\n\n"
+                    history.append((message, response))
+                    return history
+                else:
+                    history.append((message, f"Sorry, I couldn't find a paper matching '{search_term}'. Please try a more specific title."))
+                    return history
             except Exception as e:
-                history.append((message, f"Error retrieving stock data for {ticker}: {str(e)}"))
+                history.append((message, f"Error generating citation: {str(e)}"))
                 return history
                 
-        system_prompt = "You are a financial assistant specializing in analyzing financial reports, statements, and market trends."
-        system_prompt += " You can help with stock market information, financial terminology, ratio analysis, and investment concepts."
+        system_prompt = "You are an academic assistant specializing in analyzing research papers, theses, and scholarly articles."
+        system_prompt += " You can help with understanding academic content, summarizing research findings, and explaining scholarly concepts."
         if context:
             system_prompt += " Use the following context to answer the question if relevant: " + context
-        
         completion = client.chat.completions.create(
             model=model_name,
             messages=[
@@ -170,157 +294,293 @@ def update_image(page_num, pdf_state):
         print(f"Error decoding image: {e}")
         return None
 
-# New Finance-specific tools
-def get_stock_data(ticker):
-    """Tool to fetch latest stock data for a given ticker"""
+# Academic-specific tools
+def search_arxiv(query, max_results=10, sort_by=arxiv.SortCriterion.Relevance):
+    """Search for papers on arXiv"""
     try:
-        stock = yf.Ticker(ticker)
-        info = stock.info
-        return {
-            "current_price": info.get("currentPrice", info.get("regularMarketPrice", "N/A")),
-            "52wk_high": info.get("fiftyTwoWeekHigh", "N/A"),
-            "market_cap": info.get("marketCap", "N/A"),
-            "pe_ratio": info.get("trailingPE", "N/A"),
-            "dividend_yield": info.get("dividendYield", "N/A"),
-            "beta": info.get("beta", "N/A"),
-            "average_volume": info.get("averageVolume", "N/A")
+        search = arxiv.Search(
+            query=query,
+            max_results=max_results,
+            sort_by=sort_by
+        )
+        
+        results = []
+        for paper in search.results():
+            results.append({
+                "title": paper.title,
+                "authors": ", ".join(author.name for author in paper.authors),
+                "summary": paper.summary,
+                "published": paper.published.strftime("%Y-%m-%d"),
+                "url": paper.pdf_url,
+                "arxiv_id": paper.entry_id.split("/")[-1],
+                "categories": ", ".join(paper.categories)
+            })
+        
+        return results
+    except Exception as e:
+        print(f"Error searching arXiv: {e}")
+        return []
+
+def search_semantic_scholar(query, fields="title,authors,abstract,year,venue,externalIds"):
+    """Search for papers using Semantic Scholar API"""
+    api_key = os.getenv("SEMANTIC_SCHOLAR_API_KEY", "")
+    
+    try:
+        headers = {}
+        if api_key:
+            headers["x-api-key"] = api_key
+            
+        params = {
+            "query": query,
+            "fields": fields,
+            "limit": 10
         }
+        
+        response = requests.get(
+            "https://api.semanticscholar.org/graph/v1/paper/search",
+            headers=headers,
+            params=params
+        )
+        
+        if response.status_code != 200:
+            print(f"API Error: {response.status_code} - {response.text}")
+            return []
+            
+        data = response.json()
+        results = []
+        
+        for paper in data.get("data", []):
+            authors = ", ".join([author.get("name", "") for author in paper.get("authors", [])])
+            paper_data = {
+                "title": paper.get("title", "Unknown Title"),
+                "authors": authors,
+                "abstract": paper.get("abstract", "No abstract available"),
+                "year": paper.get("year", "Unknown Year"),
+                "venue": paper.get("venue", "Unknown Venue"),
+                "s2_id": paper.get("paperId", ""),
+                "url": f"https://www.semanticscholar.org/paper/{paper.get('paperId', '')}"
+            }
+            
+            # Extract external IDs if available
+            external_ids = paper.get("externalIds", {})
+            if external_ids:
+                if "DOI" in external_ids:
+                    paper_data["doi"] = external_ids["DOI"]
+                if "ArXiv" in external_ids:
+                    paper_data["arxiv_id"] = external_ids["ArXiv"]
+                    
+            results.append(paper_data)
+            
+        return results
+    except Exception as e:
+        print(f"Error in Semantic Scholar search: {e}")
+        return []
+
+def search_paper_by_title(title):
+    """Search for a specific paper by title to generate citations"""
+    try:
+        # Try Semantic Scholar first
+        results = search_semantic_scholar(title)
+        if results:
+            return results[0]  # Return the top match
+            
+        # Fallback to arXiv
+        results = search_arxiv(title, max_results=1)
+        if results:
+            return results[0]
+            
+        return None
     except Exception as e:
-        print(f"Error fetching stock data: {e}")
-        raise e
+        print(f"Error searching for paper: {e}")
+        return None
 
-def get_stock_history(ticker, period="1y"):
-    """Get historical data for charting"""
+def generate_citations(paper):
+    """Generate citations in various formats"""
     try:
-        stock = yf.Ticker(ticker)
-        hist = stock.history(period=period)
-        return hist
+        # Get current year for citations
+        current_year = datetime.now().year
+        
+        # Extract author surnames for citations
+        author_list = paper.get("authors", "").split(", ")
+        first_author_surname = author_list[0].split()[-1] if author_list else "Unknown"
+        
+        # Publication year
+        year = paper.get("year", current_year)
+        
+        # Title
+        title = paper.get("title", "Unknown Title")
+        
+        # Publication venue
+        venue = paper.get("venue", "")
+        
+        # URLs
+        url = paper.get("url", "")
+        doi = paper.get("doi", "")
+        doi_url = f"https://doi.org/{doi}" if doi else ""
+        
+        # Create citations
+        apa = f"{first_author_surname}"
+        if len(author_list) > 1:
+            apa += " et al."
+        apa += f" ({year}). {title}. "
+        if venue:
+            apa += f"{venue}. "
+        if doi:
+            apa += f"https://doi.org/{doi}"
+        elif url:
+            apa += url
+            
+        mla = f"{first_author_surname}"
+        if len(author_list) > 1:
+            mla += " et al."
+        mla += f". \"{title}.\" "
+        if venue:
+            mla += f"{venue}, "
+        mla += f"{year}. "
+        if doi:
+            mla += f"DOI: {doi}."
+        elif url:
+            mla += f"Web: {url}."
+            
+        chicago = f"{first_author_surname}"
+        if len(author_list) > 1:
+            chicago += " et al."
+        chicago += f". \"{title}.\" "
+        if venue:
+            chicago += f"{venue} "
+        chicago += f"({year})"
+        if doi or url:
+            chicago += f". Accessed {datetime.now().strftime('%B %d, %Y')}"
+            
+        return {
+            "apa": apa,
+            "mla": mla,
+            "chicago": chicago
+        }
     except Exception as e:
-        print(f"Error fetching stock history: {e}")
-        return pd.DataFrame()
+        print(f"Error generating citations: {e}")
+        return {
+            "apa": "Error generating APA citation",
+            "mla": "Error generating MLA citation",
+            "chicago": "Error generating Chicago citation"
+        }
 
-def get_fred_data(indicator):
-    """Get economic data from FRED API"""
-    api_key = os.getenv("FRED_API_KEY", "")
-    if not api_key:
-        return "FRED API key not configured"
+def perform_paper_search(query, source, category, sort_by, max_results, web_search_enabled=True):
+    """
+    Search for academic papers based on the query and parameters.
+    """
+    if not web_search_enabled:
+        return "Web search is currently disabled. Please enable web search to use this feature."
     
-    base_url = "https://api.stlouisfed.org/fred/series/observations"
-    params = {
-        "series_id": indicator,
-        "api_key": api_key,
-        "file_type": "json",
-        "sort_order": "desc",
-        "limit": 100
-    }
+    # Ensure max_results is an integer
+    if isinstance(max_results, str):
+        max_results = int(max_results)
     
+    # Rest of the function remains the same
     try:
-        response = requests.get(base_url, params=params)
-        data = response.json()
-        return data.get("observations", [])
+        results_markdown = ""
+        
+        if source == "arxiv" or source == "both":
+            arxiv_results = search_arxiv(query, max_results)
+            if arxiv_results:
+                results_markdown += "## arXiv Results\n\n"
+                for paper in arxiv_results:
+                    results_markdown += f"### [{paper['title']}]({paper['url']})\n"
+                    results_markdown += f"**Authors:** {paper['authors']}\n\n"
+                    results_markdown += f"**Published:** {paper['published']}\n\n"
+                    results_markdown += f"**Summary:** {paper['summary'][:500]}...\n\n"
+                    results_markdown += "---\n\n"
+        
+        if source == "semantic_scholar" or source == "both":
+            ss_results = search_semantic_scholar(query)
+            if ss_results:
+                results_markdown += "## Semantic Scholar Results\n\n"
+                for paper in ss_results:
+                    results_markdown += f"### [{paper['title']}]({paper['url']})\n"
+                    results_markdown += f"**Authors:** {paper['authors']}\n\n"
+                    if paper.get('abstract'):
+                        results_markdown += f"**Abstract:** {paper['abstract'][:500]}...\n\n"
+                    results_markdown += f"**Year:** {paper.get('year', 'N/A')}\n\n"
+                    results_markdown += "---\n\n"
+        
+        if not results_markdown:
+            return "No papers found for this query. Try adjusting your search terms."
+        
+        return results_markdown
     except Exception as e:
-        print(f"Error fetching FRED data: {e}")
-        return []
+        return f"Error searching for papers: {str(e)}"
 
-def create_stock_chart(ticker, period="1y"):
-    """Create an interactive stock chart using Plotly"""
+def generate_citation_from_search(query):
+    """Search for a paper and generate citations"""
     try:
-        df = get_stock_history(ticker, period)
-        if df.empty:
-            return None
+        if not query:
+            return "Please enter a paper title to cite"
             
-        fig = go.Figure()
-        
-        # Add candlestick chart
-        fig.add_trace(
-            go.Candlestick(
-                x=df.index,
-                open=df['Open'],
-                high=df['High'],
-                low=df['Low'],
-                close=df['Close'],
-                name=ticker
-            )
-        )
+        paper = search_paper_by_title(query)
         
-        # Add volume as bar chart on secondary y-axis
-        fig.add_trace(
-            go.Bar(
-                x=df.index,
-                y=df['Volume'],
-                name='Volume',
-                marker_color='rgba(0, 128, 0, 0.3)',
-                yaxis='y2'
-            )
-        )
+        if not paper:
+            return "No matching papers found. Try a more specific title."
+            
+        citations = generate_citations(paper)
         
-        # Update layout for dual y-axis
-        fig.update_layout(
-            title=f'{ticker} Stock Price',
-            yaxis_title='Price (USD)',
-            xaxis_title='Date',
-            template='plotly_white',
-            yaxis=dict(
-                domain=[0.3, 1.0]
-            ),
-            yaxis2=dict(
-                domain=[0, 0.2],
-                title='Volume'
-            ),
-            legend=dict(
-                orientation="h",
-                yanchor="bottom",
-                y=1.02,
-                xanchor="right",
-                x=1
-            ),
-            height=500
-        )
+        markdown = f"## Citation for: {paper['title']}\n\n"
+        markdown += "### APA Format\n"
+        markdown += f"```\n{citations['apa']}\n```\n\n"
+        markdown += "### MLA Format\n"
+        markdown += f"```\n{citations['mla']}\n```\n\n"
+        markdown += "### Chicago Format\n"
+        markdown += f"```\n{citations['chicago']}\n```\n\n"
         
-        return fig
+        if paper.get('url'):
+            markdown += f"[View Original Paper]({paper['url']})\n"
+            
+        return markdown
     except Exception as e:
-        print(f"Error creating stock chart: {e}")
-        return None
+        return f"Error generating citation: {str(e)}"
 
-def analyze_ticker(ticker_input, period):
-    """Process the ticker input and return analysis"""
-    if not ticker_input:
-        return None, "Please enter a valid ticker symbol", None
+# Update the citation generation function to check for web search toggle
+def generate_citation(query, web_search_enabled=True):
+    """
+    Generate citations for a paper based on its title.
+    """
+    if not web_search_enabled:
+        return "Web search is currently disabled. Please enable web search to use this feature."
     
-    ticker = ticker_input.strip().upper()
-    if ticker.startswith("$"):
-        ticker = ticker[1:]
+    if not query:
+        return "Please enter a paper title to generate citations."
     
     try:
-        stock_data = get_stock_data(ticker)
-        chart = create_stock_chart(ticker, period)
-        
-        # Create a formatted summary
-        summary = f"""
-### {ticker} Analysis
-**Current Price:** ${stock_data['current_price']}  
-**52-Week High:** ${stock_data['52wk_high']}  
-**Market Cap:** ${stock_data['market_cap']:,}  
-**P/E Ratio:** {stock_data['pe_ratio']}  
-**Dividend Yield:** {stock_data['dividend_yield'] * 100 if stock_data['dividend_yield'] != 'N/A' else 'N/A'}%  
-**Beta:** {stock_data['beta']}  
-**Avg Volume:** {stock_data['average_volume']:,}  
-        """
-        
-        return chart, summary, ticker
+        # Search for the paper first
+        papers = search_semantic_scholar(query)
+        
+        if not papers:
+            return "Could not find the paper. Please check the title and try again."
+        
+        paper = papers[0]
+        
+        # Generate citations using the generate_citations function
+        citations = generate_citations(paper)
+        
+        # Format the result as markdown
+        citation_md = "## Citation Formats\n\n"
+        citation_md += f"### APA Style\n```\n{citations['apa']}\n```\n\n"
+        citation_md += f"### MLA Style\n```\n{citations['mla']}\n```\n\n"
+        citation_md += f"### Chicago Style\n```\n{citations['chicago']}\n```\n\n"
+        
+        return citation_md
     except Exception as e:
-        return None, f"Error analyzing ticker {ticker}: {str(e)}", None
+        return f"Error generating citations: {str(e)}"
 
 # Gradio interface
 with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
     current_session_id = gr.State(None)
     pdf_state = gr.State({"page_images": [], "total_pages": 0, "total_words": 0})
-    current_ticker = gr.State(None)
+    audio_output = gr.State(None)
     
     gr.HTML("""
     <div class="header">
-        <div class="header-title">Fin-Vision</div>
-        <div class="header-subtitle">Analyze financial documents with Groq's LLM API.</div>
+        <div class="header-title">Scholar-Vision</div>
+        <div class="header-subtitle">Analyze academic papers and research with Groq's LLM API.</div>
     </div>
     """)
     
@@ -329,25 +589,55 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
             pdf_file = gr.File(label="Upload PDF Document", file_types=[".pdf"], type="binary")
             upload_button = gr.Button("Process PDF", variant="primary")
             pdf_status = gr.Markdown("No PDF uploaded yet")
+            
+            # Web Search Toggle
+            with gr.Row(elem_classes="toggle-container"):
+                gr.Markdown("Academic Search:", elem_classes="toggle-label")
+                web_search_toggle = gr.Checkbox(label="Enable Web Search", value=True, elem_classes="search-toggle")
+            
             model_dropdown = gr.Dropdown(
                 choices=["llama3-70b-8192", "llama3-8b-8192", "mixtral-8x7b-32768", "gemma-7b-it"],
                 value="llama3-70b-8192",
                 label="Select Groq Model"
             )
             
-            # Finance Tools Section
-            gr.Markdown("### Financial Tools", elem_classes="tool-title")
+            # Academic Tools Section
+            gr.Markdown("### Academic Tools", elem_classes="tool-title")
             with gr.Group(elem_classes="tool-container"):
                 with gr.Tabs():
-                    with gr.TabItem("Stock Analysis"):
-                        ticker_input = gr.Textbox(label="Enter Ticker Symbol (e.g., AAPL)", placeholder="AAPL")
-                        period_dropdown = gr.Dropdown(
-                            choices=["1mo", "3mo", "6mo", "1y", "2y", "5y", "max"],
-                            value="1y",
-                            label="Time Period"
+                    with gr.TabItem("Paper Search"):
+                        paper_query = gr.Textbox(label="Search Query", placeholder="Enter keywords to search for papers")
+                        with gr.Row():
+                            paper_source = gr.Dropdown(
+                                choices=["arxiv", "semantic_scholar", "both"],
+                                value="arxiv",
+                                label="Source"
+                            )
+                            paper_category = gr.Dropdown(
+                                choices=["any", "cs", "physics", "math", "q-bio", "econ", "eess", "stat"],
+                                value="any",
+                                label="Category"
+                            )
+                        paper_sort = gr.Dropdown(
+                            choices=["relevance", "date", "citations"],
+                            value="relevance",
+                            label="Sort By"
                         )
-                        analyze_button = gr.Button("Analyze Stock")
-            
+                        max_results = gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Max Results")
+                        paper_search_btn = gr.Button("Search Papers")
+                    
+                    with gr.TabItem("Citation Generator"):
+                        citation_query = gr.Textbox(label="Paper Title", placeholder="Enter the paper title for citation")
+                        citation_btn = gr.Button("Generate Citations")
+                        
+                    with gr.TabItem("Image Analysis"):
+                        image_input = gr.File(
+                            label="Upload Image", 
+                            file_types=["image"],
+                            type="filepath"
+                        )
+                        analyze_btn = gr.Button("Analyze Image")
+                
         with gr.Column(scale=2, min_width=600):
             with gr.Tabs():
                 with gr.TabItem("PDF Viewer"):
@@ -356,18 +646,32 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
                         pdf_image = gr.Image(label="PDF Page", type="pil", elem_classes="pdf-viewer-image")
                         stats_display = gr.Markdown("No PDF uploaded yet", elem_classes="stats-box")
                 
-                with gr.TabItem("Stock Analysis"):
-                    with gr.Column(elem_classes="pdf-viewer-container"):
-                        stock_chart = gr.Plot(label="Stock Price Chart", elem_classes="chart-container")
-                        stock_summary = gr.Markdown("Enter a ticker symbol to see analysis")
+                with gr.TabItem("Paper Results"):
+                    paper_results = gr.Markdown("Search for papers to see results here")
+                
+                with gr.TabItem("Citation Results"):
+                    citation_results = gr.Markdown("Generate citations to see results here")
+                    
+                with gr.TabItem("Image Analysis Results"):
+                    image_analysis_results = gr.Markdown("Upload an image and click 'Analyze Image' to see analysis results")
+                    image_preview = gr.Image(label="Image Preview", type="pil")
     
     with gr.Row(elem_classes="container"):
         with gr.Column(scale=2, min_width=600):
             chatbot = gr.Chatbot(height=500, bubble_full_width=False, show_copy_button=True, elem_classes="chat-container")
             with gr.Row():
-                msg = gr.Textbox(show_label=False, placeholder="Ask about your financial document or type $TICKER for stock info...", scale=5)
+                msg = gr.Textbox(
+                    show_label=False, 
+                    placeholder="Ask about your paper or click the microphone icon to speak...", 
+                    scale=5
+                )
+                voice_btn = gr.Button("🎤", elem_classes="voice-btn")
                 send_btn = gr.Button("Send", scale=1)
-            clear_btn = gr.Button("Clear Conversation")
+                
+            with gr.Row(elem_classes="audio-controls"):
+                clear_btn = gr.Button("Clear Conversation")
+                speak_btn = gr.Button("🔊 Speak Response", elem_classes="speak-btn")
+                audio_player = gr.Audio(label="Response Audio", type="filepath", visible=False)
     
     # Event Handlers
     upload_button.click(
@@ -382,20 +686,45 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
     
     msg.submit(
         generate_response,
-        inputs=[msg, current_session_id, model_dropdown, chatbot],
+        inputs=[msg, current_session_id, model_dropdown, chatbot, web_search_toggle],
         outputs=[chatbot]
     ).then(lambda: "", None, [msg])
     
     send_btn.click(
         generate_response,
-        inputs=[msg, current_session_id, model_dropdown, chatbot],
+        inputs=[msg, current_session_id, model_dropdown, chatbot, web_search_toggle],
         outputs=[chatbot]
     ).then(lambda: "", None, [msg])
     
+    # Speech-to-text button handler
+    voice_btn.click(
+        speech_to_text,
+        inputs=[],
+        outputs=[msg]
+    )
+    
+    # Text-to-speech button handler
+    speak_btn.click(
+        text_to_speech,
+        inputs=["", chatbot],  # Empty string for the text parameter, we'll use the last message from history
+        outputs=[audio_player]
+    ).then(
+        lambda x: gr.update(visible=True) if x else gr.update(visible=False),
+        inputs=[audio_player],
+        outputs=[audio_player]
+    )
+    
+    # Update display when web search toggle changes
+    web_search_toggle.change(
+        lambda x: f"Academic Search {'Enabled' if x else 'Disabled'}",
+        inputs=[web_search_toggle],
+        outputs=[pdf_status]
+    )
+    
     clear_btn.click(
-        lambda: ([], None, "No PDF uploaded yet", {"page_images": [], "total_pages": 0, "total_words": 0}, 0, None, "No PDF uploaded yet", None),
+        lambda: ([], None, "No PDF uploaded yet", {"page_images": [], "total_pages": 0, "total_words": 0}, 0, None, "No PDF uploaded yet", None, gr.update(visible=False)),
         None,
-        [chatbot, current_session_id, pdf_status, pdf_state, page_slider, pdf_image, stats_display, current_ticker]
+        [chatbot, current_session_id, pdf_status, pdf_state, page_slider, pdf_image, stats_display, audio_player, audio_player]
     )
     
     page_slider.change(
@@ -404,19 +733,36 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
         outputs=[pdf_image]
     )
     
-    # Stock analysis handler
-    analyze_button.click(
-        analyze_ticker,
-        inputs=[ticker_input, period_dropdown],
-        outputs=[stock_chart, stock_summary, current_ticker]
+    # Image analysis button handler
+    analyze_btn.click(
+        analyze_image,
+        inputs=[image_input],
+        outputs=[image_analysis_results]
+    ).then(
+        lambda x: Image.open(x) if x else None,
+        inputs=[image_input],
+        outputs=[image_preview]
+    )
+    
+    # Academic tool handlers
+    paper_search_btn.click(
+        perform_paper_search,
+        inputs=[paper_query, paper_source, paper_category, paper_sort, max_results, web_search_toggle],
+        outputs=[paper_results]
+    )
+    
+    citation_btn.click(
+        generate_citation,
+        inputs=[citation_query, web_search_toggle],
+        outputs=[citation_results]
     )
 
-# Add footer with attribution
-gr.HTML("""
-<div style="text-align: center; margin-top: 20px; padding: 10px; color: #666; font-size: 0.8rem; border-top: 1px solid #eee;">
-    Created by Calvin Allen Crawford
-</div>
-""")
+    # Add footer with creator attribution
+    gr.HTML("""
+    <div style="text-align: center; margin-top: 20px; padding: 10px; color: #666; font-size: 0.8rem; border-top: 1px solid #eee;">
+        Created by Calvin Allen Crawford
+    </div>
+    """)
 
 # Launch the app
 if __name__ == "__main__":