Update app.py

app.py

@@ -6,7 +6,6 @@ import base64
 import io
 import json
 import re
-import logging
 from datetime import datetime, timedelta
 
 # Third-party imports
@@ -18,18 +17,12 @@ import requests
 import fitz  # PyMuPDF
 from PIL import Image
 from dotenv import load_dotenv
-import yfinance as yf
-import plotly.graph_objects as go
-from pydantic import BaseModel, validator
 
 # LangChain imports
 from langchain_community.embeddings import HuggingFaceEmbeddings
 from langchain_community.vectorstores import FAISS
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
-# Setup logging
-logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-
 # Load environment variables
 load_dotenv()
 client = groq.Client(api_key=os.getenv("GROQ_LEGAL_API_KEY"))
@@ -42,131 +35,51 @@ FAISS_INDEX_DIR = "faiss_indexes_finance"
 if not os.path.exists(FAISS_INDEX_DIR):
     os.makedirs(FAISS_INDEX_DIR)
 
-# Dictionaries for state management
+# Dictionary to store user-specific vectorstores
 user_vectorstores = {}
+
+# Dictionary to store chart data
 chart_data_store = {}
 
-# Pydantic Models
-class PDFState(BaseModel):
-    page_images: list[str]
-    total_pages: int
-    total_words: int
-
-class StockAnalysisInput(BaseModel):
-    ticker: str
-    period: str
-
-    @validator('ticker')
-    def validate_ticker(cls, v):
-        v = v.strip().lstrip("$")
-        if not v.isalpha() or len(v) > 5:
-            raise ValueError('Invalid ticker symbol')
-        return v.upper()
-
-    @validator('period')
-    def validate_period(cls, v):
-        valid_periods = ["1mo", "3mo", "6mo", "1y", "2y", "5y", "max"]
-        if v not in valid_periods:
-            raise ValueError('Invalid period')
-        return v
-
-class ModelName(str):
-    @classmethod
-    def __get_validators__(cls):
-        yield cls.validate
-
-    @classmethod
-    def validate(cls, v):
-        allowed_models = ["llama3-70b-8192", "llama3-8b-8192", "mixtral-8x7b-32768", "gemma-7b-it"]
-        if v not in allowed_models:
-            raise ValueError(f"Invalid model name: {v}")
-        return v
-
-# Custom CSS
+# Custom CSS for Finance theme with new voice and speech buttons
 custom_css = """
 :root {
-    --bg-color: #FFFFFF;
-    --text-color: #333333;
     --primary-color: #0C4160;
     --secondary-color: #0D6980;
     --accent-color: #16A6DB;
     --light-color: #EBF5FA;
+    --dark-text: #333333;
+    --light-text: #F5F5F5;
     --border-color: #E5E7EB;
 }
-
-[data-theme="dark"] {
-    --bg-color: #1E1E1E;
-    --text-color: #F5F5F5;
-    --primary-color: #16A6DB;
-    --secondary-color: #0D6980;
-    --accent-color: #0C4160;
-    --light-color: #333333;
-    --border-color: #444444;
-}
-
-body { background-color: var(--bg-color); color: var(--text-color); font-family: 'IBM Plex Sans', sans-serif; }
+body { background-color: var(--light-color); font-family: 'IBM Plex Sans', sans-serif; }
 .container { max-width: 1200px !important; margin: 0 auto !important; padding: 10px; }
 .header { background-color: var(--primary-color); padding: 20px 0; margin-bottom: 20px; border-radius: 12px 12px 0 0; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
-.header-title { color: var(--light-color); font-size: 1.8rem; font-weight: 700; text-align: center; }
-.header-subtitle { color: var(--light-color); opacity: 0.8; 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(--bg-color) !important; border: 1px solid var(--border-color) !important; min-height: 500px; }
-.message-user { background-color: var(--accent-color) !important; color: var(--light-color) !important; border-radius: 18px 18px 4px 18px !important; padding: 12px 16px !important; margin-left: auto !important; max-width: 80% !important; }
-.message-bot { background-color: var(--light-color) !important; color: var(--text-color) !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(--bg-color) !important; border-top: 1px solid var(--border-color) !important; padding: 12px !important; border-radius: 0 0 12px 12px !important; }
+.header-title { color: var(--light-text); font-size: 1.8rem; font-weight: 700; text-align: center; }
+.header-subtitle { color: var(--light-text); opacity: 0.8; 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: #FFFFFF !important; border: 1px solid var(--border-color) !important; min-height: 500px; }
+.message-user { background-color: var(--accent-color) !important; color: var(--light-text) !important; border-radius: 18px 18px 4px 18px !important; padding: 12px 16px !important; margin-left: auto !important; max-width: 80% !important; }
+.message-bot { background-color: #F5F7FA !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: #FFFFFF !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; }
-.send-btn { background-color: var(--accent-color) !important; border-radius: 24px !important; color: var(--light-color) !important; padding: 10px 20px !important; font-weight: 500 !important; }
-.clear-btn { background-color: var(--light-color) !important; border: 1px solid var(--border-color) !important; border-radius: 24px !important; color: var(--text-color) !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(--bg-color) !important; border: 1px solid var(--border-color) !important; padding: 20px; }
+.send-btn { background-color: var(--accent-color) !important; border-radius: 24px !important; color: var(--light-text) !important; padding: 10px 20px !important; font-weight: 500 !important; }
+.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: #FFFFFF !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: var(--light-color); padding: 10px; border-radius: 8px; margin-top: 10px; }
-.tool-container { background-color: var(--bg-color); border-radius: 12px; box-shadow: 0 2px 4px rgba(0,0,0,0.05); padding: 15px; margin-bottom: 20px; }
+.tool-container { background-color: white; border-radius: 12px; box-shadow: 0 2px 4px rgba(0,0,0,0.05); padding: 15px; margin-bottom: 20px; }
 .tool-title { font-weight: bold; color: var(--primary-color); margin-bottom: 10px; font-size: 1.1rem; }
 .chart-container { height: 400px; width: 100%; border-radius: 8px; overflow: hidden; }
 .toggle-container { display: flex; align-items: center; margin-bottom: 15px; }
 .toggle-label { margin-right: 10px; font-weight: 500; }
 .search-toggle { margin-left: 5px; }
-.spinner { border: 4px solid #f3f3f3; border-top: 4px solid var(--primary-color); border-radius: 50%; width: 40px; height: 40px; animation: spin 1s linear infinite; }
-@keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
-"""
-
-# Custom JavaScript (simplified to avoid interference)
-custom_js = """
-function toggleTheme() {
-    const currentTheme = document.body.getAttribute('data-theme');
-    const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
-    document.body.setAttribute('data-theme', newTheme);
-    localStorage.setItem('theme', newTheme);
-}
-
-function showSpinner() {
-    document.getElementById('spinner').style.display = 'block';
-}
-
-function hideSpinner() {
-    document.getElementById('spinner').style.display = 'none';
-}
-
-document.addEventListener('DOMContentLoaded', () => {
-    const savedTheme = localStorage.getItem('theme');
-    if (savedTheme) {
-        document.body.setAttribute('data-theme', savedTheme);
-    }
-});
+.audio-controls { display: flex; align-items: center; margin-top: 10px; }
 """
 
-# Spinner HTML
-custom_html = """
-<div id="spinner" style="display: none; position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%);">
-    <div class="spinner"></div>
-</div>
-"""
-
-# Helper Functions
+# Function to process PDF files
 def process_pdf(pdf_file):
-    logging.debug("Processing PDF file")
     if pdf_file is None:
-        return None, "No file uploaded", PDFState(page_images=[], total_pages=0, total_words=0)
-    
+        return None, "No file uploaded", {"page_images": [], "total_pages": 0, "total_words": 0}
     try:
         session_id = str(uuid.uuid4())
         with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as temp_file:
@@ -175,7 +88,12 @@ def process_pdf(pdf_file):
         
         doc = fitz.open(pdf_path)
         texts = [page.get_text() for page in doc]
-        page_images = [base64.b64encode(page.get_pixmap().tobytes("png")).decode("utf-8") for page in doc]
+        page_images = []
+        for page in doc:
+            pix = page.get_pixmap()
+            img_bytes = pix.tobytes("png")
+            img_base64 = base64.b64encode(img_bytes).decode("utf-8")
+            page_images.append(img_base64)
         total_pages = len(doc)
         total_words = sum(len(text.split()) for text in texts)
         doc.close()
@@ -188,244 +106,628 @@ def process_pdf(pdf_file):
         user_vectorstores[session_id] = vectorstore
 
         os.unlink(pdf_path)
-        pdf_state = PDFState(page_images=page_images, total_pages=total_pages, total_words=total_words)
-        logging.debug(f"PDF processed successfully: {session_id}")
+        pdf_state = {"page_images": page_images, "total_pages": total_pages, "total_words": total_words}
         return session_id, f"✅ Successfully processed {len(chunks)} text chunks from your PDF", pdf_state
     except Exception as e:
-        logging.error(f"Error processing PDF: {str(e)}")
         if "pdf_path" in locals() and os.path.exists(pdf_path):
             os.unlink(pdf_path)
-        return None, f"Error processing PDF: {str(e)}", PDFState(page_images=[], total_pages=0, total_words=0)
+        return None, f"Error processing PDF: {str(e)}", {"page_images": [], "total_pages": 0, "total_words": 0}
 
-def serper_search(query):
+# Serper API functions for enhanced financial data
+def serper_search(query, search_type="search"):
+    """
+    Perform a search using Serper.dev API to get financial information
+    """
     if not SERPER_API_KEY:
-        return {"error": "Serper API key not configured."}
+        return {"error": "Serper API key not configured. Set SERPER_API_KEY in environment variables."}
+    
     url = "https://google.serper.dev/search"
-    payload = json.dumps({"q": query, "gl": "us", "hl": "en", "autocorrect": True})
-    headers = {'X-API-KEY': SERPER_API_KEY, 'Content-Type': 'application/json'}
+    payload = json.dumps({
+        "q": query,
+        "gl": "us",
+        "hl": "en",
+        "autocorrect": True
+    })
+    headers = {
+        'X-API-KEY': SERPER_API_KEY,
+        'Content-Type': 'application/json'
+    }
+    
     try:
-        response = requests.post(url, headers=headers, data=payload)
+        response = requests.request("POST", url, headers=headers, data=payload)
         return response.json()
     except Exception as e:
+        print(f"Error in Serper search: {e}")
         return {"error": str(e)}
 
-def brave_search(query):
+# Brave Search API functions
+def brave_search(query, search_type="search"):
+    """
+    Perform a search using Brave Search API to get financial information
+    """
     if not BRAVE_API_KEY:
-        return {"error": "Brave Search API key not configured."}
+        return {"error": "Brave Search API key not configured. Set BRAVE_API_KEY in environment variables."}
+    
     url = "https://api.search.brave.com/res/v1/web/search"
-    params = {"q": query, "count": 10, "search_lang": "en", "country": "us"}
-    headers = {'Accept': 'application/json', 'X-Subscription-Token': BRAVE_API_KEY}
+    params = {
+        "q": query,
+        "count": 10,
+        "search_lang": "en",
+        "country": "us"
+    }
+    headers = {
+        'Accept': 'application/json',
+        'Accept-Encoding': 'gzip',
+        'X-Subscription-Token': BRAVE_API_KEY
+    }
+    
     try:
         response = requests.get(url, params=params, headers=headers)
         return response.json()
     except Exception as e:
+        print(f"Error in Brave search: {e}")
         return {"error": str(e)}
 
-def get_financial_news(ticker, use_brave_search, enable_search, model_name="llama3-8b-8192"):
-    if not enable_search:
-        return [{"title": "Real-time search disabled", "snippet": "Enable real-time search to fetch news"}]
+# Add this new function for LLM-based search
+def llm_search(query, model_name="llama3-8b-8192"):
+    """
+    Fallback search using LLM when no search APIs are configured
+    """
+    try:
+        system_prompt = """You are a financial research assistant. Based on your knowledge, 
+        provide relevant information about the query. Format your response as a list of 3-5 
+        relevant pieces of information, each with a title and brief description."""
+        
+        completion = client.chat.completions.create(
+            model=model_name,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": query}
+            ],
+            temperature=0.3,
+            max_tokens=500
+        )
+        
+        # Format response as search results
+        return [{
+            "title": "LLM-Generated Results",
+            "link": "",
+            "snippet": completion.choices[0].message.content,
+            "source": "AI Knowledge Base"
+        }]
+    except Exception as e:
+        print(f"Error in LLM search: {e}")
+        return []
+
+# Update the get_financial_news function
+def get_financial_news(ticker, use_brave_search=False, model_name="llama3-8b-8192"):
+    """
+    Get latest financial news about a stock using selected search API or LLM fallback
+    """
     query = f"{ticker} stock news financial analysis latest"
+    news_items = []
+    
+    # Try Brave Search first if selected
     if use_brave_search and BRAVE_API_KEY:
         results = brave_search(query)
         if "web" in results and "results" in results["web"]:
-            return [{"title": item.get("title", ""), "link": item.get("url", ""), "snippet": item.get("description", ""), "source": item.get("source", "")} 
-                    for item in results["web"]["results"][:5]]
-    if SERPER_API_KEY:
+            for item in results["web"]["results"][:5]:
+                news_items.append({
+                    "title": item.get("title", ""),
+                    "link": item.get("url", ""),
+                    "snippet": item.get("description", ""),
+                    "source": item.get("source", "")
+                })
+            return news_items
+    
+    # Try Serper API if Brave Search is not used or failed
+    if not news_items and SERPER_API_KEY:
         results = serper_search(query)
         if "organic" in results:
-            return [{"title": item.get("title", ""), "link": item.get("link", ""), "snippet": item.get("snippet", ""), "source": item.get("source", "")} 
-                    for item in results["organic"][:5]]
-    return [{"title": "No news available", "snippet": "Search APIs not configured or failed."}]
-
-def get_market_sentiment(ticker, use_brave_search, enable_search, model_name="llama3-8b-8192"):
-    if not enable_search:
-        return "Real-time search is disabled"
+            for item in results["organic"][:5]:
+                news_items.append({
+                    "title": item.get("title", ""),
+                    "link": item.get("link", ""),
+                    "snippet": item.get("snippet", ""),
+                    "source": item.get("source", "")
+                })
+            return news_items
+    
+    # Fallback to LLM if no API results
+    if not news_items:
+        return llm_search(f"Provide recent financial news and analysis about {ticker} stock", model_name)
+
+# Update the get_market_sentiment function
+def get_market_sentiment(ticker, use_brave_search=False, model_name="llama3-8b-8192"):
+    """
+    Get market sentiment for a stock using selected search API or LLM fallback
+    """
     query = f"{ticker} stock market sentiment analysis"
     snippets = []
+    
+    # Try Brave Search first if selected
     if use_brave_search and BRAVE_API_KEY:
         results = brave_search(query)
         if "web" in results and "results" in results["web"]:
-            snippets = [item["description"] for item in results["web"]["results"][:3] if "description" in item]
-    elif SERPER_API_KEY:
+            for item in results["web"]["results"][:3]:
+                if "description" in item:
+                    snippets.append(item["description"])
+    
+    # Try Serper API if Brave Search is not used or failed
+    if not snippets and SERPER_API_KEY:
         results = serper_search(query)
         if "organic" in results:
-            snippets = [item["snippet"] for item in results["organic"][:3] if "snippet" in item]
+            for item in results["organic"][:3]:
+                if "snippet" in item:
+                    snippets.append(item["snippet"])
+    
+    # Generate sentiment analysis
     if snippets:
+        combined_snippets = "\n".join(snippets)
+    else:
+        # If no API results, use LLM to generate market sentiment directly
+        system_prompt = f"""You are a financial analyst. Based on your knowledge, 
+        provide a brief market sentiment analysis for {ticker} stock. Consider recent 
+        trends, company performance, and market conditions."""
+        
         try:
             completion = client.chat.completions.create(
-                model=ModelName.validate(model_name),
+                model=model_name,
                 messages=[
-                    {"role": "system", "content": "Analyze the sentiment based on the provided text."},
-                    {"role": "user", "content": "\n".join(snippets)}
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"What is the current market sentiment for {ticker} stock?"}
                 ],
                 temperature=0.2,
                 max_tokens=150
             )
             return completion.choices[0].message.content
         except Exception as e:
+            print(f"Error in LLM sentiment analysis: {e}")
             return "Unable to determine sentiment"
-    return "No sentiment data available"
-
-def get_stock_data(ticker, enable_stock_data):
-    if not enable_stock_data:
-        return {"message": "Real-time stock data is disabled"}
-    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")
-        }
-    except Exception as e:
-        raise e
-
-def get_stock_history(ticker, period, enable_stock_data):
-    if not enable_stock_data:
-        return pd.DataFrame()
-    try:
-        stock = yf.Ticker(ticker)
-        return stock.history(period=period)
-    except Exception as e:
-        return pd.DataFrame()
-
-def create_stock_chart(ticker, period, enable_stock_data):
-    if not enable_stock_data:
-        return None
-    df = get_stock_history(ticker, period, enable_stock_data)
-    if df.empty:
-        return None
-    fig = go.Figure()
-    fig.add_trace(go.Candlestick(x=df.index, open=df['Open'], high=df['High'], low=df['Low'], close=df['Close'], name=ticker))
-    fig.add_trace(go.Bar(x=df.index, y=df['Volume'], name='Volume', marker_color='rgba(0, 128, 0, 0.3)', yaxis='y2'))
-    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'),
-        height=500
-    )
-    return fig
-
-def analyze_ticker(ticker_input, period, use_brave_search, enable_stock_data, enable_search):
-    logging.debug(f"Analyzing ticker: {ticker_input}, period: {period}")
-    try:
-        input_data = StockAnalysisInput(ticker=ticker_input, period=period)
-    except ValueError as e:
-        logging.error(f"Validation error: {str(e)}")
-        return None, str(e), None
-    
-    ticker = input_data.ticker
-    period = input_data.period
-    
-    if not enable_stock_data:
-        return None, "Real-time stock data is disabled.", None
     
+    # If we have API snippets, analyze them
     try:
-        stock_data = get_stock_data(ticker, enable_stock_data)
-        stock_history = get_stock_history(ticker, period, enable_stock_data)
-        chart = create_stock_chart(ticker, period, enable_stock_data)
-        chart_data_store[ticker] = {"history": stock_history, "stats": stock_data, "period": period}
-        sentiment = get_market_sentiment(ticker, use_brave_search, enable_search, model_name="llama3-8b-8192")
-        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']}  
-**Market Sentiment:** {sentiment}
-"""
-        logging.debug(f"Ticker {ticker} analyzed successfully")
-        return chart, summary, ticker
+        completion = client.chat.completions.create(
+            model=model_name,
+            messages=[
+                {"role": "system", "content": "You are a financial sentiment analyzer. Based on the text provided, determine if the market sentiment for the stock is positive, negative, or neutral. Provide a brief explanation."},
+                {"role": "user", "content": combined_snippets}
+            ],
+            temperature=0.2,
+            max_tokens=150
+        )
+        return completion.choices[0].message.content
     except Exception as e:
-        logging.error(f"Error analyzing ticker {ticker}: {str(e)}")
-        return None, f"Error analyzing ticker {ticker}: {str(e)}", None
+        print(f"Error analyzing sentiment: {e}")
+        return "Unable to determine sentiment"
 
-def generate_response(message, session_id, model_name, history, current_ticker, use_brave_search, enable_search, enable_stock_data):
-    logging.debug(f"Generating response for message: {message}")
+# Function to generate chatbot responses with Finance theme
+def generate_response(message, session_id, model_name, history, current_ticker=None, use_brave_search=False):
     if not message:
         return history
-    
-    try:
-        model_name = ModelName.validate(model_name)
-    except ValueError as e:
-        logging.error(f"Model validation error: {str(e)}")
-        return history + [(message, str(e))]
-    
     try:
         context = ""
-        if session_id in user_vectorstores:
+        if session_id and session_id in user_vectorstores:
             vectorstore = user_vectorstores[session_id]
             docs = vectorstore.similarity_search(message, k=3)
             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()
-            stock_data = get_stock_data(ticker, enable_stock_data)
-            news = get_financial_news(ticker, use_brave_search, enable_search, model_name)
-            sentiment = get_market_sentiment(ticker, use_brave_search, enable_search, model_name)
-            response = f"**Stock Information for {ticker}**\n\n"
-            if "message" in stock_data:
-                response += stock_data["message"] + "\n"
-            else:
-                response += f"Current Price: ${stock_data['current_price']}\n52-Week High: ${stock_data['52wk_high']}\nMarket Cap: ${stock_data['market_cap']:,}\nP/E Ratio: {stock_data['pe_ratio']}\n"
-            response += f"**Market Sentiment:**\n{sentiment}\n\n**Recent News:**\n"
-            for i, item in enumerate(news[:3]):
-                response += f"{i+1}. [{item['title']}]({item['link']})\n   {item['snippet'][:100]}...\n"
-            history.append((message, response))
-            logging.debug(f"Stock response generated for {ticker}")
-            return history
+            try:
+                stock_data = get_stock_data(ticker)
+                news = get_financial_news(ticker, use_brave_search)
+                sentiment = get_market_sentiment(ticker, use_brave_search)
+                
+                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\n"
+                response += f"**Market Sentiment:**\n{sentiment}\n\n"
+                response += "**Recent News:**\n"
+                
+                for i, news_item in enumerate(news[:3]):
+                    response += f"{i+1}. [{news_item['title']}]({news_item['link']})\n"
+                    response += f"   {news_item['snippet'][:100]}...\n\n"
+                
+                response += f"More data available in the Stock Analysis tab."
+                history.append((message, response))
+                return history
+            except Exception as e:
+                history.append((message, f"Error retrieving stock data for {ticker}: {str(e)}"))
+                return history
         
+        # Check if it's a news search request
         if message.lower().startswith("/news "):
             topic = message[6:].strip()
-            news = get_financial_news(topic, use_brave_search, enable_search, model_name)
-            response = f"**Latest Financial News on {topic}:**\n\n"
-            for i, item in enumerate(news[:5]):
-                response += f"{i+1}. **{item['title']}**\n   {item['snippet']}\n   [Read more]({item['link']})\n\n"
+            news = get_financial_news(topic, use_brave_search)
+            
+            if news:
+                search_provider = "Brave Search" if use_brave_search else "Serper"
+                response = f"**Latest Financial News on {topic} (via {search_provider}):**\n\n"
+                for i, news_item in enumerate(news[:5]):
+                    response += f"{i+1}. **{news_item['title']}**\n"
+                    response += f"   Source: {news_item['source']}\n"
+                    response += f"   {news_item['snippet']}\n"
+                    response += f"   [Read more]({news_item['link']})\n\n"
+            else:
+                response = f"No recent news found for {topic}."
+                
             history.append((message, response))
-            logging.debug(f"News response generated for {topic}")
             return history
         
+        # Check if it's a chart analysis request
+        if message.lower() == "/chart" or message.lower().startswith("/analyze chart"):
+            if current_ticker and current_ticker in chart_data_store:
+                chart_context = generate_chart_context(current_ticker)
+                
+                # Get additional market analysis using selected search API
+                market_context = ""
+                try:
+                    news = get_financial_news(current_ticker, use_brave_search)
+                    sentiment = get_market_sentiment(current_ticker, use_brave_search)
+                    market_context = f"\n\nMarket Sentiment: {sentiment}\n\nRecent News Context:"
+                    for item in news[:2]:
+                        market_context += f"\n- {item['title']}: {item['snippet'][:150]}..."
+                except Exception as e:
+                    print(f"Error getting additional market context: {e}")
+                
+                system_prompt = "You are a financial analyst specializing in stock market analysis. You have been provided with chart and financial data for a stock, along with recent market sentiment and news. Analyze this data and provide insights about the stock's performance trends, potential support/resistance levels, and overall pattern."
+                completion = client.chat.completions.create(
+                    model=model_name,
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": f"Analyze this stock data and chart information:\n\n{chart_context}{market_context}"}
+                    ],
+                    temperature=0.7,
+                    max_tokens=1024
+                )
+                response = completion.choices[0].message.content
+                history.append((message, response))
+                return history
+            else:
+                history.append((message, "Please analyze a stock first using the Stock Analysis tab before requesting chart analysis."))
+                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."
+        
+        # Add chart context if available
+        if current_ticker and current_ticker in chart_data_store and ("chart" in message.lower() or "stock" in message.lower() or current_ticker.lower() in message.lower()):
+            chart_context = generate_chart_context(current_ticker)
+            context += f"\n\nRecent stock data for {current_ticker}:\n{chart_context}"
+            
+            # Add news and sentiment if it's a stock-related query
+            try:
+                news = get_financial_news(current_ticker, use_brave_search)
+                sentiment = get_market_sentiment(current_ticker, use_brave_search)
+                context += f"\n\nMarket Sentiment: {sentiment}\n\nRecent News Headlines:"
+                for item in news[:2]:
+                    context += f"\n- {item['title']}"
+            except Exception as e:
+                print(f"Error adding news context: {e}")
+        
         if context:
-            system_prompt += " Use the following context if relevant: " + context
+            system_prompt += " Use the following context to answer the question if relevant: " + context
+        
         completion = client.chat.completions.create(
             model=model_name,
-            messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": message}],
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": message}
+            ],
             temperature=0.7,
             max_tokens=1024
         )
         response = completion.choices[0].message.content
         history.append((message, response))
-        logging.debug("Chat response generated")
         return history
     except Exception as e:
-        logging.error(f"Error generating response: {str(e)}")
-        return history + [(message, f"Error generating response: {str(e)}")]
+        history.append((message, f"Error generating response: {str(e)}"))
+        return history
 
-def update_pdf_viewer(pdf_state: PDFState):
-    if not pdf_state.total_pages:
+# Helper function to generate chart context for LLM
+def generate_chart_context(ticker):
+    data = chart_data_store[ticker]
+    df = data["history"]
+    stats = data["stats"]
+    
+    # Calculate key metrics from the chart data
+    start_price = df["Close"].iloc[0]
+    end_price = df["Close"].iloc[-1]
+    percent_change = ((end_price - start_price) / start_price) * 100
+    highest = df["High"].max()
+    lowest = df["Low"].min()
+    
+    # Calculate average volume
+    avg_volume = df["Volume"].mean()
+    
+    # Calculate simple moving averages
+    if len(df) > 50:
+        sma_50 = df["Close"].rolling(window=50).mean().iloc[-1]
+    else:
+        sma_50 = "Not enough data"
+    
+    if len(df) > 200:
+        sma_200 = df["Close"].rolling(window=200).mean().iloc[-1]
+    else:
+        sma_200 = "Not enough data"
+    
+    # Calculate RSI (Relative Strength Index)
+    delta = df['Close'].diff()
+    gain = delta.where(delta > 0, 0).rolling(window=14).mean()
+    loss = -delta.where(delta < 0, 0).rolling(window=14).mean()
+    rs = gain / loss
+    rsi = 100 - (100 / (1 + rs.iloc[-1])) if not pd.isna(rs.iloc[-1]) and loss.iloc[-1] != 0 else 50
+    
+    # Calculate volatility (standard deviation of returns)
+    returns = df['Close'].pct_change()
+    volatility = returns.std() * 100  # Annualize by multiplying by sqrt(252)
+    
+    # Get recent price movement (last 5 days)
+    recent_prices = []
+    if len(df) >= 5:
+        for i in range(1, 6):
+            if i <= len(df):
+                recent_prices.append(df["Close"].iloc[-i])
+    
+    # Format the context for the LLM
+    context = f"""
+Ticker: {ticker}
+Period: {data["period"]}
+Current Price: ${end_price:.2f}
+Price Change: {percent_change:.2f}%
+52-Week High: ${stats['52wk_high']}
+52-Week Low: ${lowest:.2f}
+Market Cap: ${stats['market_cap']:,}
+P/E Ratio: {stats['pe_ratio']}
+Average Volume: {avg_volume:.0f}
+Volatility: {volatility:.2f}%
+RSI (14-day): {rsi:.2f}
+"""
+
+    if isinstance(sma_50, float):
+        context += f"50-day Moving Average: ${sma_50:.2f}\n"
+    if isinstance(sma_200, float):
+        context += f"200-day Moving Average: ${sma_200:.2f}\n"
+        
+    context += "\nRecent Price Movement (last 5 days, most recent first):\n"
+    for i, price in enumerate(recent_prices):
+        context += f"Day {i+1}: ${price:.2f}\n"
+    
+    return context
+
+# Functions to update PDF viewer (unchanged)
+def update_pdf_viewer(pdf_state):
+    if not pdf_state["total_pages"]:
         return 0, None, "No PDF uploaded yet"
-    img_data = base64.b64decode(pdf_state.page_images[0])
-    img = Image.open(io.BytesIO(img_data))
-    return pdf_state.total_pages, img, f"**Total Pages:** {pdf_state.total_pages}\n**Total Words:** {pdf_state.total_words}"
+    try:
+        img_data = base64.b64decode(pdf_state["page_images"][0])
+        img = Image.open(io.BytesIO(img_data))
+        return pdf_state["total_pages"], img, f"**Total Pages:** {pdf_state['total_pages']}\n**Total Words:** {pdf_state['total_words']}"
+    except Exception as e:
+        print(f"Error decoding image: {e}")
+        return 0, None, "Error displaying PDF"
 
-def update_image(page_num, pdf_state: PDFState):
-    if not pdf_state.total_pages or page_num < 1 or page_num > pdf_state.total_pages:
+def update_image(page_num, pdf_state):
+    if not pdf_state["total_pages"] or page_num < 1 or page_num > pdf_state["total_pages"]:
+        return None
+    try:
+        img_data = base64.b64decode(pdf_state["page_images"][page_num - 1])
+        img = Image.open(io.BytesIO(img_data))
+        return img
+    except Exception as e:
+        print(f"Error decoding image: {e}")
         return None
-    img_data = base64.b64decode(pdf_state.page_images[page_num - 1])
-    return Image.open(io.BytesIO(img_data))
 
-# Gradio Interface
+# New Finance-specific tools
+def get_stock_data(ticker):
+    """Tool to fetch latest stock data for a given ticker"""
+    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")
+        }
+    except Exception as e:
+        print(f"Error fetching stock data: {e}")
+        raise e
+
+def get_stock_history(ticker, period="1y"):
+    """Get historical data for charting"""
+    try:
+        stock = yf.Ticker(ticker)
+        hist = stock.history(period=period)
+        return hist
+    except Exception as e:
+        print(f"Error fetching stock history: {e}")
+        return pd.DataFrame()
+
+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"
+    
+    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
+    }
+    
+    try:
+        response = requests.get(base_url, params=params)
+        data = response.json()
+        return data.get("observations", [])
+    except Exception as e:
+        print(f"Error fetching FRED data: {e}")
+        return []
+
+def create_stock_chart(ticker, period="1y"):
+    """Create an interactive stock chart using Plotly"""
+    try:
+        df = get_stock_history(ticker, period)
+        if df.empty:
+            return None
+            
+        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
+            )
+        )
+        
+        # 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'
+            )
+        )
+        
+        # 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
+        )
+        
+        return fig
+    except Exception as e:
+        print(f"Error creating stock chart: {e}")
+        return None
+
+def analyze_ticker(ticker_input, period, use_brave_search=False):
+    """Process the ticker input and return analysis"""
+    if not ticker_input:
+        return None, "Please enter a valid ticker symbol", None
+    
+    ticker = ticker_input.strip().upper()
+    if ticker.startswith("$"):
+        ticker = ticker[1:]
+    
+    try:
+        stock_data = get_stock_data(ticker)
+        stock_history = get_stock_history(ticker, period)
+        chart = create_stock_chart(ticker, period)
+        
+        # Store chart data for LLM analysis
+        chart_data_store[ticker] = {
+            "history": stock_history,
+            "stats": stock_data,
+            "period": period
+        }
+        
+        # Get market sentiment using selected search API or LLM fallback
+        try:
+            sentiment = get_market_sentiment(ticker, use_brave_search)
+            sentiment_summary = f"\n\n**Market Sentiment:**\n{sentiment}"
+        except Exception as e:
+            print(f"Error getting sentiment: {e}")
+            sentiment_summary = ""
+        
+        # Create a formatted summary
+        search_provider = "Brave Search" if (use_brave_search and BRAVE_API_KEY) else "Serper" if SERPER_API_KEY else "AI Knowledge Base"
+        summary = f"""
+### {ticker} Analysis (Using {search_provider})
+
+**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']:,}  
+{sentiment_summary}
+
+For in-depth analysis of this chart, ask the chatbot by typing "/chart" or "/analyze chart".
+For latest news, type "/news {ticker}".
+        """
+        
+        return chart, summary, ticker
+    except Exception as e:
+        return None, f"Error analyzing ticker {ticker}: {str(e)}", None
+
+# Replace the load_docling_model function with a simpler image analysis function
+def analyze_image(image_file):
+    """
+    Basic image analysis function that doesn't rely on external models
+    """
+    if image_file is None:
+        return "No image uploaded. Please upload an image to analyze."
+    
+    try:
+        image = Image.open(image_file)
+        width, height = image.size
+        format = image.format
+        mode = image.mode
+        
+        analysis = f"""## Technical Document Analysis
+
+**Image Properties:**
+- Dimensions: {width}x{height} pixels
+- Format: {format}
+- Color Mode: {mode}
+
+**Technical Analysis:**
+1. Document Quality:
+   - Resolution: {'High' if width > 2000 or height > 2000 else 'Medium' if width > 1000 or height > 1000 else 'Low'}
+   - Color Depth: {mode}
+
+2. Recommendations:
+   - For text extraction, consider using PDF format
+   - For technical diagrams, ensure high resolution
+   - Consider OCR for text content
+   
+**Note:** For detailed technical analysis, please convert to PDF format
+"""
+        return analysis
+    except Exception as e:
+        return f"Error analyzing image: {str(e)}\n\nPlease try using PDF format instead."
+
+# Update the Gradio interface
 def create_interface():
-    with gr.Blocks(css=custom_css, js=custom_js) as demo:
-        gr.HTML(custom_html)
+    with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
         current_session_id = gr.State(None)
-        pdf_state = gr.State(PDFState(page_images=[], total_pages=0, total_words=0))
+        pdf_state = gr.State({"page_images": [], "total_pages": 0, "total_words": 0})
         current_ticker = gr.State(None)
         
         gr.HTML("""
@@ -437,114 +739,149 @@ def create_interface():
         
         with gr.Row(elem_classes="container"):
             with gr.Column(scale=1, min_width=300):
-                pdf_file = gr.File(label="Upload PDF Document", file_types=[".pdf"], type="binary", elem_id="pdf_file")
+                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")
                 
-                with gr.Group():
-                    gr.Markdown("### Real-Time Data Settings")
-                    enable_stock_data = gr.Checkbox(label="Enable Real-Time Stock Data", value=True)
-                    enable_search = gr.Checkbox(label="Enable Real-Time Search", value=True)
-                    use_brave_search = gr.Checkbox(label="Use Brave Search (unchecked = Serper)", value=False)
-                
+                # Search Engine Toggle
+                with gr.Row(elem_classes="toggle-container"):
+                    gr.Markdown("Search Provider:", elem_classes="toggle-label")
+                    use_brave_search = gr.Checkbox(
+                        label="Use Brave Search (unchecked = Serper)", 
+                        value=False, 
+                        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"
                 )
-                theme_button = gr.Button("Toggle Theme")
                 
+                # Finance Tools Section
+                gr.Markdown("### Financial Tools", elem_classes="tool-title")
                 with gr.Group(elem_classes="tool-container"):
-                    ticker_input = gr.Textbox(label="Enter Ticker Symbol (e.g., AAPL)", placeholder="AAPL", elem_id="ticker_input")
-                    period_dropdown = gr.Dropdown(choices=["1mo", "3mo", "6mo", "1y", "2y", "5y", "max"], value="1y", label="Time Period")
-                    analyze_button = gr.Button("Analyze Stock")
+                    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"
+                            )
+                            analyze_button = gr.Button("Analyze Stock")
+                        
+                        with gr.TabItem("Image Analysis"):
+                            gr.Markdown("""
+                            ### Basic Image Analysis
+                            Upload an image to see basic properties and recommendations.
+                            For detailed document analysis, please use PDF format.
+                            """)
+                            image_input = gr.File(
+                                label="Upload Document 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"):
-                        page_slider = gr.Slider(minimum=1, maximum=1, step=1, label="Page Number", value=1)
-                        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.Column(elem_classes="pdf-viewer-container"):
+                            page_slider = gr.Slider(minimum=1, maximum=1, step=1, label="Page Number", value=1)
+                            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"):
-                        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.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("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"):
-            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...", scale=5)
-                send_btn = gr.Button("Send", scale=1)
-        
+            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 click the microphone icon to speak...", 
+                        scale=5
+                    )
+                    send_btn = gr.Button("Send", scale=1)
+            
         # Event Handlers
         upload_button.click(
-            fn=process_pdf,
+            process_pdf,
             inputs=[pdf_file],
-            outputs=[current_session_id, pdf_status, pdf_state],
-            _js="showSpinner"
+            outputs=[current_session_id, pdf_status, pdf_state]
         ).then(
-            fn=update_pdf_viewer,
+            update_pdf_viewer,
             inputs=[pdf_state],
             outputs=[page_slider, pdf_image, stats_display]
-        ).then(
-            fn=None,
-            _js="hideSpinner",
-            inputs=[],
-            outputs=[]
-        )
-        
-        analyze_button.click(
-            fn=analyze_ticker,
-            inputs=[ticker_input, period_dropdown, use_brave_search, enable_stock_data, enable_search],
-            outputs=[stock_chart, stock_summary, current_ticker],
-            _js="showSpinner"
-        ).then(
-            fn=None,
-            _js="hideSpinner",
-            inputs=[],
-            outputs=[]
         )
         
         msg.submit(
-            fn=generate_response,
-            inputs=[msg, current_session_id, model_dropdown, chatbot, current_ticker, use_brave_search, enable_search, enable_stock_data],
+            generate_response,
+            inputs=[msg, current_session_id, model_dropdown, chatbot, current_ticker, use_brave_search],
             outputs=[chatbot]
-        ).then(
-            fn=lambda: "",
-            inputs=None,
-            outputs=[msg]
-        )
+        ).then(lambda: "", None, [msg])
         
         send_btn.click(
-            fn=generate_response,
-            inputs=[msg, current_session_id, model_dropdown, chatbot, current_ticker, use_brave_search, enable_search, enable_stock_data],
-            outputs=[chatbot],
-            _js="showSpinner"
-        ).then(
-            fn=lambda: "",
-            inputs=None,
-            outputs=[msg]
-        ).then(
-            fn=None,
-            _js="hideSpinner",
-            inputs=[],
-            outputs=[]
+            generate_response,
+            inputs=[msg, current_session_id, model_dropdown, chatbot, current_ticker, use_brave_search],
+            outputs=[chatbot]
+        ).then(lambda: "", None, [msg])
+        
+        # Update display when search provider changes
+        use_brave_search.change(
+            lambda x: f"Using {'Brave Search' if x else 'Serper'} API for queries",
+            inputs=[use_brave_search],
+            outputs=[pdf_status]
         )
         
         page_slider.change(
-            fn=update_image,
+            update_image,
             inputs=[page_slider, pdf_state],
             outputs=[pdf_image]
         )
-        theme_button.click(
-            fn=None,
-            _js="toggleTheme",
-            inputs=[],
-            outputs=[]
+        
+        # Stock analysis handler
+        analyze_button.click(
+            analyze_ticker,
+            inputs=[ticker_input, period_dropdown, use_brave_search],
+            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]
+        )
+
+        clear_btn.click(
+            lambda: ([], None, "No PDF uploaded yet", {"page_images": [], "total_pages": 0, "total_words": 0}, 0, None, "No PDF uploaded yet"),
+            None,
+            [chatbot, current_session_id, pdf_status, pdf_state, page_slider, pdf_image, stats_display]
+        )
+
     return demo
 
+# 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>
+""")
+
+# Launch the app
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch(debug=True)  # Enable debug mode to see logs in console
+    demo.launch()