Update app.py

app.py

@@ -10,6 +10,7 @@ from datetime import datetime, timedelta
 
 # Third-party imports
 import gradio as gr
+import groq
 import numpy as np
 import pandas as pd
 import requests
@@ -17,39 +18,32 @@ import fitz  # PyMuPDF
 from PIL import Image
 from dotenv import load_dotenv
 import torch
-import yfinance as yf
-import plotly.graph_objects as go
 
-# Assuming groq is a custom module or typo; replace with actual import if needed
-from groq import Client as GroqClient  # Adjust based on your setup
-
-# LangChain imports (optional, only if embeddings are available)
-try:
-    from langchain_community.embeddings import HuggingFaceEmbeddings  # Changed to basic embeddings
-    from langchain_community.vectorstores import FAISS
-    from langchain.text_splitter import RecursiveCharacterTextSplitter
-    langchain_available = True
-except ImportError:
-    langchain_available = False
-    print("LangChain dependencies not found. PDF processing will be limited.")
+# LangChain imports
+from langchain_community.embeddings import HuggingFaceInstructEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 # Load environment variables
 load_dotenv()
-client = GroqClient(api_key=os.getenv("GROQ_LEGAL_API_KEY"))
+client = groq.Client(api_key=os.getenv("GROQ_LEGAL_API_KEY"))
 
 # Embeddings initialization with fallback
-if langchain_available:
+try:
+    embeddings = HuggingFaceInstructEmbeddings(
+        model_name="hkunlp/instructor-base",
+        model_kwargs={"device": "cuda" if torch.cuda.is_available() else "cpu"}
+    )
+except Exception as e:
+    print(f"Warning: Failed to load primary embeddings model: {e}")
     try:
-        embeddings = HuggingFaceEmbeddings(
-            model_name="sentence-transformers/all-MiniLM-L6-v2",
+        embeddings = HuggingFaceInstructEmbeddings(
+            model_name="all-MiniLM-L6-v2",
             model_kwargs={"device": "cuda" if torch.cuda.is_available() else "cpu"}
         )
     except Exception as e:
-        print(f"Warning: Failed to load embeddings model: {e}")
+        print(f"Warning: Failed to load fallback embeddings model: {e}")
         embeddings = None
-else:
-    embeddings = None
-    print("Embeddings disabled due to missing LangChain dependencies.")
 
 SERPER_API_KEY = os.getenv("SERPER_API_KEY")
 BRAVE_API_KEY = os.getenv("BRAVE_API_KEY")
@@ -65,7 +59,7 @@ user_vectorstores = {}
 # Dictionary to store chart data
 chart_data_store = {}
 
-# Custom CSS (unchanged)
+# Custom CSS for Finance theme with new voice and speech buttons
 custom_css = """
 :root {
     --primary-color: #0C4160;
@@ -99,7 +93,7 @@ body { background-color: var(--light-color); font-family: 'IBM Plex Sans', sans-
 .search-toggle { margin-left: 5px; }
 """
 
-# Function definitions
+# Function to process PDF files
 def process_pdf(pdf_file):
     if pdf_file is None:
         return None, "No file uploaded", {"page_images": [], "total_pages": 0, "total_words": 0}
@@ -121,76 +115,211 @@ def process_pdf(pdf_file):
         total_words = sum(len(text.split()) for text in texts)
         doc.close()
 
-        if langchain_available and embeddings:
-            text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-            chunks = text_splitter.create_documents(texts)
-            vectorstore = FAISS.from_documents(chunks, embeddings)
-            index_path = os.path.join(FAISS_INDEX_DIR, session_id)
-            vectorstore.save_local(index_path)
-            user_vectorstores[session_id] = vectorstore
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+        chunks = text_splitter.create_documents(texts)
+        vectorstore = FAISS.from_documents(chunks, embeddings)
+        index_path = os.path.join(FAISS_INDEX_DIR, session_id)
+        vectorstore.save_local(index_path)
+        user_vectorstores[session_id] = vectorstore
 
         os.unlink(pdf_path)
         pdf_state = {"page_images": page_images, "total_pages": total_pages, "total_words": total_words}
-        return session_id, f"✅ Successfully processed {len(texts)} pages from your PDF", pdf_state
+        return session_id, f"✅ Successfully processed {len(chunks)} text chunks from your PDF", pdf_state
     except Exception as e:
         if "pdf_path" in locals() and os.path.exists(pdf_path):
             os.unlink(pdf_path)
         return None, f"Error processing PDF: {str(e)}", {"page_images": [], "total_pages": 0, "total_words": 0}
 
-def update_pdf_viewer(pdf_state):
-    if not pdf_state["total_pages"]:
-        return 0, None, "No PDF uploaded yet"
+# 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. 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'
+    }
+    
     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']}"
+        response = requests.request("POST", url, headers=headers, data=payload)
+        return response.json()
     except Exception as e:
-        print(f"Error decoding image: {e}")
-        return 0, None, "Error displaying PDF"
+        print(f"Error in Serper search: {e}")
+        return {"error": str(e)}
 
-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
+# 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. 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',
+        'Accept-Encoding': 'gzip',
+        'X-Subscription-Token': BRAVE_API_KEY
+    }
+    
     try:
-        img_data = base64.b64decode(pdf_state["page_images"][page_num - 1])
-        img = Image.open(io.BytesIO(img_data))
-        return img
+        response = requests.get(url, params=params, headers=headers)
+        return response.json()
     except Exception as e:
-        print(f"Error decoding image: {e}")
-        return None
+        print(f"Error in Brave search: {e}")
+        return {"error": str(e)}
 
-def analyze_ticker(ticker, period, web_search_enabled):
+# 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:
-        stock = yf.Ticker(ticker)
-        hist = stock.history(period=period)
-        if hist.empty:
-            return None, f"No data found for {ticker}", ticker
+        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."""
         
-        fig = go.Figure()
-        fig.add_trace(go.Candlestick(
-            x=hist.index,
-            open=hist['Open'],
-            high=hist['High'],
-            low=hist['Low'],
-            close=hist['Close'],
-            name='OHLC'
-        ))
-        fig.update_layout(
-            title=f'{ticker} Stock Price ({period})',
-            yaxis_title='Price',
-            template='plotly_white'
+        completion = client.chat.completions.create(
+            model=model_name,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": query}
+            ],
+            temperature=0.3,
+            max_tokens=500
         )
         
-        analysis = f"## {ticker} Analysis\n\n"
-        analysis += f"Latest Close: ${hist['Close'][-1]:.2f}\n"
-        analysis += f"52 Week High: ${hist['High'].max():.2f}\n"
-        analysis += f"52 Week Low: ${hist['Low'].min():.2f}\n"
+        # 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"]:
+            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:
+            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"]:
+            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:
+            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."""
         
-        return fig, analysis, ticker
+        try:
+            completion = client.chat.completions.create(
+                model=model_name,
+                messages=[
+                    {"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"
+    
+    # If we have API snippets, analyze them
+    try:
+        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:
-        return None, f"Error analyzing ticker: {str(e)}", ticker
+        print(f"Error analyzing sentiment: {e}")
+        return "Unable to determine sentiment"
 
-def generate_response(message, session_id, model_name, history, ticker, web_search_enabled):
+# 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:
@@ -199,12 +328,105 @@ def generate_response(message, session_id, model_name, history, ticker, web_sear
             vectorstore = user_vectorstores[session_id]
             docs = vectorstore.similarity_search(message, k=3)
             if docs:
-                context = "\n\nRelevant information from uploaded document:\n" + "\n".join(f"- {doc.page_content}" for doc in 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)
+                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)
+            
+            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))
+            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}")
         
-        system_prompt = "You are a financial assistant specializing in analyzing markets, stocks, and financial documents."
-        system_prompt += " You can help with understanding financial data, analyzing stocks, and explaining financial concepts."
-        if ticker:
-            system_prompt += f" Current ticker in focus: {ticker}"
         if context:
             system_prompt += " Use the following context to answer the question if relevant: " + context
         
@@ -214,19 +436,311 @@ def generate_response(message, session_id, model_name, history, ticker, web_sear
                 {"role": "system", "content": system_prompt},
                 {"role": "user", "content": message}
             ],
-            temperature=0.5,
+            temperature=0.7,
             max_tokens=1024
         )
         response = completion.choices[0].message.content
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": response})
+        history.append((message, response))
         return history
     except Exception as e:
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": f"Error generating response: {str(e)}"})
+        history.append((message, f"Error generating response: {str(e)}"))
         return history
 
-# Gradio interface
+# 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"
+    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):
+    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
+
+# 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
 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})
@@ -239,7 +753,9 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
     </div>
     """)
     
+    # Main container with all functionality in tabs
     with gr.Tabs() as main_tabs:
+        # Chat Assistant Tab
         with gr.TabItem("💬 Chat Assistant", id=0):
             with gr.Row():
                 with gr.Column(scale=1):
@@ -258,8 +774,7 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
                 height=600,
                 show_copy_button=True,
                 elem_classes="chat-container",
-                container=True,
-                type="messages"
+                container=True
             )
             with gr.Row():
                 msg = gr.Textbox(
@@ -270,6 +785,7 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
                 send_btn = gr.Button("Send", scale=1)
             clear_btn = gr.Button("Clear Conversation")
 
+        # Document Analysis Tab
         with gr.TabItem("📄 Document Analysis", id=1):
             with gr.Row():
                 with gr.Column(scale=1):
@@ -294,8 +810,10 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
                             pdf_image = gr.Image(label="Document Page", type="pil")
                             stats_display = gr.Markdown(elem_classes="stats-box")
 
+        # Financial Tools Tab
         with gr.TabItem("🔍 Financial Tools", id=2):
             with gr.Tabs() as financial_tabs:
+                # Stock Analysis
                 with gr.TabItem("Stock Analysis"):
                     with gr.Row():
                         with gr.Column():
@@ -313,48 +831,40 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
                         stock_chart = gr.Plot(label="Stock Price Chart")
                     stock_analysis = gr.Markdown()
 
-    # Event Handlers
-    send_btn.click(
-        fn=generate_response,
-        inputs=[msg, current_session_id, model_dropdown, chatbot, current_ticker, web_search_toggle],
-        outputs=[chatbot]
-    )
-    
-    clear_btn.click(
-        fn=lambda: [],
-        inputs=None,
-        outputs=[chatbot],
-        queue=False
-    )
-
-    upload_button.click(
-        fn=process_pdf,
-        inputs=[pdf_file],
-        outputs=[current_session_id, pdf_status, pdf_state]
-    ).then(
-        fn=update_pdf_viewer,
-        inputs=[pdf_state],
-        outputs=[page_slider, pdf_image, stats_display]
-    )
-
-    page_slider.change(
-        fn=update_image,
-        inputs=[page_slider, pdf_state],
-        outputs=[pdf_image]
-    )
+                # Market News
+                with gr.TabItem("Market News"):
+                    news_ticker = gr.Textbox(
+                        label="Company/Ticker",
+                        placeholder="Enter company name or ticker symbol"
+                    )
+                    news_btn = gr.Button("Fetch News")
+                    news_results = gr.Markdown()
 
-    analyze_stock_btn.click(
-        fn=analyze_ticker,
-        inputs=[ticker_input, period_dropdown, web_search_toggle],
-        outputs=[stock_chart, stock_analysis, current_ticker]
-    )
+                # Financial Report Analysis
+                with gr.TabItem("Report Analysis"):
+                    with gr.Row():
+                        with gr.Column():
+                            report_image = gr.File(
+                                label="Upload Financial Chart/Image",
+                                file_types=["image"],
+                                type="filepath"
+                            )
+                            analyze_report_btn = gr.Button("Analyze Image")
+                        with gr.Column():
+                            report_preview = gr.Image(label="Preview", type="pil")
+                    report_analysis = gr.Markdown()
+    
+    # Event Handlers
+    # [Add appropriate event handlers based on fin-vision functions]
 
-    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 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()