Initial deploy to Hugging Face Spaces

Clean history with no binary model files.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

CLAUDE.md

@@ -0,0 +1,110 @@
+# CLAUDE.md
+
+## Quick Start
+
+```bash
+cd be && pip install -r requirements.txt
+# Add POLYGON_API_KEY and GEMINI_API_KEY to .env
+python app.py
+# Open http://localhost:5000
+```
+
+## Project Overview
+
+Stock research assistant with Polygon.io data, AI chatbot (ReAct agent with tool calling), and social media sentiment analysis.
+
+## Architecture
+
+```
+fe/          Vanilla JS frontend (no frameworks)
+be/          Python Flask backend
+  app.py              Main Flask app, stock data routes
+  agent_service.py    ReAct agent loop (tool calling + streaming)
+  agent_tools.py      10 tool schemas + ToolExecutor with 3-layer cache
+  llm_client.py       AgentLLMClient (google-genai SDK) + ConversationManager
+  chat_routes.py      SSE streaming with structured events
+  rag_pipeline.py     FAISS vector store, embeddings (google-genai SDK)
+  sentiment_*.py      Social sentiment (FinBERT, scrapers)
+  forecast_*.py       LSTM price forecasting
+  polygon_api.py      Polygon.io wrapper
+  chat_service.py     Legacy RAG chat (replaced by agent_service.py)
+```
+
+## Chat Agent Architecture
+
+The chat uses a **ReAct-style agent** with Gemini 2.0 Flash function calling:
+
+1. User sends message → `agent_service.py` builds conversation contents
+2. Gemini decides which tools to call based on the question
+3. `ToolExecutor` runs tools with 3-layer caching (frontend context → server cache → API)
+4. Results fed back to Gemini as function responses
+5. Loop repeats (max 5 iterations) until Gemini returns a text response
+6. Final text streamed to frontend via structured SSE events
+
+**10 Available Tools:** `get_stock_quote`, `get_company_info`, `get_financials`, `get_news`, `search_knowledge_base`, `analyze_sentiment`, `get_price_forecast`, `get_dividends`, `get_stock_splits`, `get_price_history`
+
+**SSE Event Protocol:**
+- `event: tool_call` — Agent is calling a tool (status: calling/complete/error)
+- `event: text` — Response text chunk
+- `event: done` — Stream complete
+- `event: error` — Fatal error
+
+## Key Technical Decisions
+
+- **Frontend**: Pure vanilla JS - no frameworks allowed
+- **AI SDK**: `google-genai` (new SDK) for chat + embeddings. Old `google-generativeai` still installed but only used by legacy `GeminiClient`
+- **Agent**: Gemini function calling with manual dispatch (automatic calling disabled)
+- **Vector DB**: FAISS local storage (`be/faiss_index/`)
+- **Scraping**: cloudscraper for Cloudflare bypass (StockTwits, Reddit)
+- **Sentiment**: FinBERT model (lazy-loaded, ~500MB)
+
+## API Keys (.env)
+
+```bash
+POLYGON_API_KEY=     # Stock data (5 calls/min free tier)
+GEMINI_API_KEY=      # Chat + embeddings (free)
+TWITTER_BEARER_TOKEN= # Optional, paid ($100+/month)
+```
+
+## Rate Limits
+
+- **Polygon.io**: 5 calls/min (free tier) — handled by 3-layer cache in ToolExecutor
+  - Layer 1: Frontend sends cached data as `context` in chat request
+  - Layer 2: Server-side TTL cache (5 min) in `ToolCache`
+  - Layer 3: Live API call (last resort)
+- **Gemini**: 15 RPM chat, 1500 RPM embeddings (free tier)
+
+## Main Endpoints
+
+| Endpoint | Purpose |
+|----------|---------|
+| `POST /api/chat/message` | Agent chat with structured SSE streaming |
+| `POST /api/chat/scrape-articles` | RAG article indexing into FAISS |
+| `POST /api/sentiment/analyze` | Sentiment analysis |
+| `POST /api/forecast/predict/<ticker>` | LSTM price forecast |
+
+## Where to Find Details
+
+| Topic | Location |
+|-------|----------|
+| Agent loop & tool calling | `be/agent_service.py`, `be/agent_tools.py` |
+| Tool schemas (10 tools) | `be/agent_tools.py` - TOOL_DECLARATIONS |
+| 3-layer caching | `be/agent_tools.py` - ToolExecutor._check_frontend_context() |
+| LLM client (function calling) | `be/llm_client.py` - AgentLLMClient |
+| Frontend SSE parser | `fe/app.js` - parseSSEBuffer(), sendChatMessage() |
+| Frontend caching strategy | `fe/app.js` - stockCache object |
+| Chart implementation | `fe/app.js` - chartState, drawChart functions |
+| RAG pipeline / FAISS | `be/rag_pipeline.py` |
+| Sentiment bias corrections | `be/sentiment_service.py` - aggregate calculation |
+| Social scrapers | `be/social_scrapers.py` |
+| Design system | `.design-engineer/system.md` |
+
+## Development Rules
+
+1. Keep frontend vanilla JS - no frameworks
+2. Respect caching TTLs (see stockCache in app.js)
+3. FAISS namespaces: `news:` for articles, `sentiment:` for posts
+4. FinBERT has bullish bias - see sentiment_service.py for corrections
+5. Tool responses use `role="tool"` in Gemini API (not "user")
+6. Embeddings use `result.embeddings[0].values` with new google-genai SDK
+7. `chat_service.py` is legacy — all new chat work goes through `agent_service.py`

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# System deps needed by faiss-cpu, lxml, and torch
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install CPU-only torch first to avoid the 2.5 GB CUDA download
+RUN pip install --no-cache-dir \
+    torch==2.1.0+cpu \
+    --extra-index-url https://download.pytorch.org/whl/cpu
+
+# Install gunicorn and remaining dependencies
+COPY be/requirements.txt .
+RUN pip install --no-cache-dir gunicorn && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY be/ ./be/
+COPY fe/ ./fe/
+COPY company_tickers.json .
+
+# Create writable directories for runtime data
+# (FAISS index and forecast models are regenerated each restart on free tier)
+RUN mkdir -p /app/be/faiss_index /app/be/forecast_models /app/be/sentiment_cache
+
+WORKDIR /app/be
+
+EXPOSE 7860
+
+# Use shell form so ${PORT:-7860} is expanded at runtime
+# gthread workers allow concurrent SSE streaming without blocking
+CMD ["sh", "-c", "gunicorn --bind 0.0.0.0:${PORT:-7860} --worker-class gthread --workers 1 --threads 4 --timeout 300 app:app"]

README.md

@@ -0,0 +1,179 @@
+---
+title: MarketLens
+emoji: 📈
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# MarketLens - Stock Research Assistant
+
+A personal stock research assistant that provides real-time market information and AI-powered insights. Users can explore stock data, news, earnings, and performance metrics powered by the Polygon API.
+
+## Project Structure
+
+```
+MarketLens/
+├── be/                          # Python backend
+│   ├── app.py                   # Flask application
+│   ├── config.py                # Configuration management
+│   ├── polygon_api.py           # Polygon API client
+│   └── requirements.txt         # Python dependencies
+├── fe/                          # JavaScript frontend
+│   ├── index.html              # Main HTML page
+│   ├── app.js                  # Frontend logic
+│   └── styles.css              # Styling
+├── company_tickers.json        # List of stock tickers
+├── .env.example                # Environment variables template
+└── README.md                   # This file
+```
+
+## Features
+
+- **Stock Selection**: Search and select from thousands of stock tickers
+- **Real-time Data**: View current market data including price, volume, and market cap
+- **Price Charts**: Interactive charts with multiple timeframes (1M, 3M, 6M, 1Y, 5Y)
+- **Financial Data**: Access quarterly and annual financial statements
+- **News Feed**: Latest news articles related to selected stocks
+- **Clean UI**: Simple, responsive interface built with vanilla JavaScript
+
+## Setup Instructions
+
+### Prerequisites
+
+- Python 3.8 or higher
+- Polygon API key (get one at [polygon.io](https://polygon.io/))
+
+### 1. Install Python Dependencies
+
+Navigate to the project directory and install the required Python packages:
+
+```bash
+cd "MarketLens"
+pip install -r be/requirements.txt
+```
+
+### 2. Configure API Key
+
+Create a `.env` file in the project root directory:
+
+```bash
+cp .env.example .env
+```
+
+Edit the `.env` file and add your Polygon API key:
+
+```
+POLYGON_API_KEY=your_actual_api_key_here
+PORT=5000
+```
+
+**Important**: Get your free Polygon API key from [https://polygon.io/](https://polygon.io/)
+
+### 3. Run the Application
+
+Start the Flask backend server:
+
+```bash
+cd be
+python app.py
+```
+
+The application will start on `http://localhost:5000`
+
+### 4. Access the Application
+
+Open your web browser and navigate to:
+
+```
+http://localhost:5000
+```
+
+## Usage
+
+1. **Search for a Stock**: Use the search box to filter stocks by ticker symbol or company name
+2. **Select a Stock**: Click on a stock from the dropdown list
+3. **Explore Data**: Navigate through different tabs:
+   - **Overview**: Key metrics and company description
+   - **Chart**: Price performance over various timeframes
+   - **Financials**: Quarterly and annual financial statements
+   - **News**: Latest news articles about the company
+
+## API Endpoints
+
+The backend provides the following REST API endpoints:
+
+- `GET /api/ticker/<ticker>/details` - Get detailed ticker information
+- `GET /api/ticker/<ticker>/previous-close` - Get previous day's close data
+- `GET /api/ticker/<ticker>/aggregates` - Get historical price data
+- `GET /api/ticker/<ticker>/news` - Get news articles
+- `GET /api/ticker/<ticker>/financials` - Get financial statements
+- `GET /api/ticker/<ticker>/snapshot` - Get current market snapshot
+
+## Technology Stack
+
+### Backend
+- **Flask**: Lightweight Python web framework
+- **Requests**: HTTP library for API calls
+- **python-dotenv**: Environment variable management
+- **Flask-CORS**: Cross-origin resource sharing
+
+### Frontend
+- **Vanilla JavaScript**: No frameworks, pure JavaScript
+- **HTML5 Canvas**: For rendering price charts
+- **CSS3**: Modern styling with flexbox and grid
+
+## Polygon API
+
+This application uses the Polygon API to fetch:
+- Real-time and historical stock prices
+- Company information and details
+- Financial statements
+- News articles
+- Market snapshots
+
+API Documentation: [https://polygon.io/docs](https://polygon.io/docs)
+
+## Development
+
+### Running in Development Mode
+
+The Flask server runs in debug mode by default, which provides:
+- Auto-reload on code changes
+- Detailed error messages
+- Interactive debugger
+
+### Environment Variables
+
+- `POLYGON_API_KEY`: Your Polygon API key (required)
+- `PORT`: Server port (default: 5000)
+
+## Troubleshooting
+
+### API Key Issues
+- Ensure your `.env` file is in the project root directory
+- Verify your API key is valid at [polygon.io](https://polygon.io/)
+- Check that the API key is properly set in the `.env` file
+
+### CORS Errors
+- Make sure Flask-CORS is installed: `pip install Flask-CORS`
+- The backend should be running on `http://localhost:5000`
+
+### No Data Displayed
+- Check browser console for error messages
+- Verify the backend server is running
+- Ensure your Polygon API key has sufficient permissions
+
+## License
+
+This is a personal project for educational and personal use.
+
+## Future Enhancements
+
+- AI-powered stock analysis and recommendations
+- Portfolio tracking
+- Real-time price updates with WebSockets
+- Advanced charting with technical indicators
+- User authentication and saved preferences

be/agent_service.py

@@ -0,0 +1,206 @@
+"""
+ReAct-style agent service that replaces the static RAG chat pipeline.
+Uses Gemini function calling to dynamically fetch data through tools.
+"""
+
+import json
+import logging
+
+from google.genai import types as genai_types
+from llm_client import AgentLLMClient, ConversationManager
+from agent_tools import TOOL_DECLARATIONS, ToolExecutor
+from rag_pipeline import VectorStore, ContextRetriever
+from polygon_api import PolygonAPI
+from config import AGENT_MAX_ITERATIONS
+
+logger = logging.getLogger(__name__)
+
+
+class AgentService:
+    """Orchestrates the ReAct agent loop with tool calling."""
+
+    def __init__(self):
+        self.polygon = PolygonAPI()
+        self.vector_store = VectorStore()
+        self.context_retriever = ContextRetriever(vector_store=self.vector_store)
+        self.llm_client = AgentLLMClient()
+        self.conversation_manager = ConversationManager()
+        self.tool_executor = ToolExecutor(
+            polygon_api=self.polygon,
+            context_retriever=self.context_retriever,
+            vector_store=self.vector_store,
+        )
+
+    def process_message(self, ticker, message, frontend_context, conversation_id):
+        """
+        Process a user message through the ReAct agent loop.
+
+        Yields (event_type, data) tuples for SSE streaming:
+          - ("tool_call", {"tool": str, "args": dict, "status": "calling"|"complete"|"error"})
+          - ("text", str)
+          - ("done", {})
+
+        Args:
+            ticker: Stock ticker symbol
+            message: User message
+            frontend_context: Cached data from frontend (Layer 1 cache)
+            conversation_id: Conversation session ID
+        """
+        try:
+            ticker = ticker.upper() if ticker else ""
+
+            # Prime the tool executor with frontend context (Layer 1)
+            self.tool_executor.set_context(frontend_context, ticker)
+
+            # Build conversation contents from history
+            history = self.conversation_manager.get_history(conversation_id)
+            contents = self.llm_client.history_to_contents(history)
+
+            # Append user message
+            contents.append(self.llm_client.make_user_content(message))
+
+            # Build config with tools
+            config = self.llm_client.build_config(TOOL_DECLARATIONS, ticker)
+
+            # ReAct loop
+            for iteration in range(AGENT_MAX_ITERATIONS):
+                logger.info(f"Agent iteration {iteration + 1}/{AGENT_MAX_ITERATIONS}")
+
+                response = self.llm_client.generate(contents, config)
+                function_calls, text_parts, response_content = self.llm_client.extract_parts(response)
+
+                if not function_calls:
+                    # Final text response — stream it in chunks
+                    final_text = "".join(text_parts)
+                    if not final_text:
+                        final_text = "I wasn't able to generate a response. Please try again."
+
+                    chunk_size = 20
+                    for i in range(0, len(final_text), chunk_size):
+                        yield ("text", final_text[i:i + chunk_size])
+
+                    yield ("done", {})
+
+                    # Save to conversation history (only user message + final text)
+                    self.conversation_manager.add_message(conversation_id, "user", message)
+                    self.conversation_manager.add_message(conversation_id, "assistant", final_text)
+                    return
+
+                # Process function calls
+                contents.append(response_content)
+
+                tool_response_parts = []
+                for part in function_calls:
+                    fc = part.function_call
+                    tool_name = fc.name
+                    tool_args = dict(fc.args) if fc.args else {}
+
+                    # Notify frontend: tool call starting
+                    yield ("tool_call", {
+                        "tool": tool_name,
+                        "args": tool_args,
+                        "status": "calling",
+                    })
+
+                    # Execute the tool
+                    result = self.tool_executor.execute(tool_name, tool_args)
+
+                    # Notify frontend: tool call complete
+                    if "error" in result:
+                        yield ("tool_call", {
+                            "tool": tool_name,
+                            "status": "error",
+                            "error": result["error"],
+                        })
+                    else:
+                        yield ("tool_call", {
+                            "tool": tool_name,
+                            "status": "complete",
+                        })
+
+                    # Build function response Part for Gemini
+                    tool_response_parts.append(
+                        genai_types.Part.from_function_response(
+                            name=tool_name, response={"result": result}
+                        )
+                    )
+
+                # Add all tool responses as a single Content with multiple Parts
+                # Gemini requires all function responses for a turn in one Content object
+                contents.append(genai_types.Content(role="tool", parts=tool_response_parts))
+
+            # Hit max iterations — provide a fallback
+            yield ("text", "I gathered some information but reached the maximum number of analysis steps. Please try a more specific question.")
+            yield ("done", {})
+
+        except Exception as e:
+            logger.error(f"Agent error: {e}", exc_info=True)
+            yield ("error", {"message": f"An error occurred: {str(e)}"})
+
+    def scrape_and_embed_articles(self, ticker, articles):
+        """
+        Background job to scrape and embed news articles into FAISS.
+        Delegates to the same logic as the old ChatService.
+        """
+        from scraper import ArticleScraper
+        from rag_pipeline import EmbeddingGenerator
+        import concurrent.futures
+        import hashlib
+
+        scraper = ArticleScraper()
+        embedding_gen = EmbeddingGenerator()
+
+        results = {"scraped": 0, "embedded": 0, "failed": 0, "skipped": 0}
+
+        def process_article(article):
+            try:
+                article_url = article.get("article_url", "")
+                doc_id = f"{ticker}_news_{hashlib.md5(article_url.encode()).hexdigest()[:12]}"
+
+                if self.vector_store.document_exists(doc_id):
+                    return "skipped"
+
+                content = scraper.scrape_article(article_url)
+                if not content:
+                    content = article.get("description", "")
+                    if not content or len(content) < 50:
+                        return "failed"
+
+                embedding = embedding_gen.generate_embedding(content)
+                if not embedding:
+                    return "failed"
+
+                metadata = {
+                    "ticker": ticker,
+                    "type": "news_article",
+                    "title": article.get("title", ""),
+                    "url": article_url,
+                    "published_date": article.get("published_utc", ""),
+                    "source": article.get("publisher", {}).get("name", "Unknown"),
+                    "content_preview": content[:200],
+                    "full_content": content,
+                }
+
+                success = self.vector_store.upsert_document(doc_id, embedding, metadata)
+                return "embedded" if success else "failed"
+
+            except Exception as e:
+                logger.error(f"Error processing article: {e}")
+                return "failed"
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+            futures = [executor.submit(process_article, a) for a in articles[:20]]
+            for future in concurrent.futures.as_completed(futures):
+                status = future.result()
+                if status == "embedded":
+                    results["embedded"] += 1
+                    results["scraped"] += 1
+                elif status == "skipped":
+                    results["skipped"] += 1
+                elif status == "failed":
+                    results["failed"] += 1
+
+        if results["embedded"] > 0:
+            self.vector_store.save()
+
+        return results

be/agent_tools.py

@@ -0,0 +1,648 @@
+"""
+Tool definitions and executor for the ReAct agent.
+Maps Gemini function declarations to existing backend services.
+Includes hybrid caching: frontend context -> server cache -> API call.
+"""
+
+import time
+import logging
+from datetime import datetime, timedelta
+
+from polygon_api import PolygonAPI
+from rag_pipeline import ContextRetriever
+from sentiment_service import get_sentiment_service
+from forecast_service import get_forecast_service
+
+logger = logging.getLogger(__name__)
+
+
+# -- Tool Schemas (Gemini function declarations) --
+
+TOOL_DECLARATIONS = [
+    {
+        "name": "get_stock_quote",
+        "description": "Get the most recent closing price, open, high, low, and volume for a stock ticker. Use this when the user asks about current price, today's price, or recent trading data.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol, e.g. AAPL"
+                }
+            },
+            "required": ["ticker"]
+        }
+    },
+    {
+        "name": "get_company_info",
+        "description": "Get detailed company information including name, description, market cap, sector, industry, and exchange. Use this when the user asks about what a company does, its sector, or general company details.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol, e.g. AAPL"
+                }
+            },
+            "required": ["ticker"]
+        }
+    },
+    {
+        "name": "get_financials",
+        "description": "Get recent financial statements including revenue, net income, gross profit, total assets, and liabilities. Returns the last 4 filing periods. Use this for questions about earnings, revenue, profitability, or balance sheet.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol, e.g. AAPL"
+                }
+            },
+            "required": ["ticker"]
+        }
+    },
+    {
+        "name": "get_news",
+        "description": "Get recent news articles about a stock. Returns headlines, sources, dates, and descriptions. Use this when the user asks about recent news, headlines, or events.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol, e.g. AAPL"
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of articles to return (default 10, max 20)"
+                }
+            },
+            "required": ["ticker"]
+        }
+    },
+    {
+        "name": "search_knowledge_base",
+        "description": "Semantic search over previously indexed news articles and research. Use this when the user asks about a specific topic and you need in-depth article content beyond headlines.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "Natural language search query"
+                },
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol to filter results"
+                }
+            },
+            "required": ["query", "ticker"]
+        }
+    },
+    {
+        "name": "analyze_sentiment",
+        "description": "Analyze social media sentiment for a stock by scraping StockTwits, Reddit, and Twitter posts and running FinBERT analysis. This operation takes 10-30 seconds. Use when the user asks about sentiment, social media buzz, or what people think about a stock.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol, e.g. AAPL"
+                }
+            },
+            "required": ["ticker"]
+        }
+    },
+    {
+        "name": "get_price_forecast",
+        "description": "Get an LSTM neural network price forecast for the next 30 trading days. May take 30-60 seconds if the model needs training. Use when the user asks about price predictions or forecasts.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol, e.g. AAPL"
+                }
+            },
+            "required": ["ticker"]
+        }
+    },
+    {
+        "name": "get_dividends",
+        "description": "Get dividend payment history including ex-dividend dates, pay dates, and amounts. Use when the user asks about dividends, yield, or dividend history.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol, e.g. AAPL"
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of dividend records to return (default 10)"
+                }
+            },
+            "required": ["ticker"]
+        }
+    },
+    {
+        "name": "get_stock_splits",
+        "description": "Get stock split history including execution dates and split ratios. Use when the user asks about stock splits.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol, e.g. AAPL"
+                }
+            },
+            "required": ["ticker"]
+        }
+    },
+    {
+        "name": "get_price_history",
+        "description": "Get historical OHLCV price data for a date range. Use when the user asks about price trends, historical performance, or needs to compare prices between dates.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {
+                    "type": "string",
+                    "description": "Stock ticker symbol, e.g. AAPL"
+                },
+                "from_date": {
+                    "type": "string",
+                    "description": "Start date in YYYY-MM-DD format"
+                },
+                "to_date": {
+                    "type": "string",
+                    "description": "End date in YYYY-MM-DD format"
+                },
+                "timespan": {
+                    "type": "string",
+                    "description": "Time interval for each bar: day, week, or month (default: day)"
+                }
+            },
+            "required": ["ticker", "from_date", "to_date"]
+        }
+    }
+]
+
+
+class ToolCache:
+    """Server-side TTL cache for tool results (Layer 2)."""
+
+    def __init__(self, ttl_seconds=300):
+        self._cache = {}
+        self._ttl = ttl_seconds
+
+    def get(self, key):
+        entry = self._cache.get(key)
+        if entry and time.time() - entry["ts"] < self._ttl:
+            return entry["data"]
+        return None
+
+    def set(self, key, data):
+        self._cache[key] = {"data": data, "ts": time.time()}
+
+
+class ToolExecutor:
+    """
+    Executes tool calls using a 3-layer cache strategy:
+    Layer 1: Frontend context (passed per-request via set_context)
+    Layer 2: Server-side TTL cache (ToolCache, 5-min TTL)
+    Layer 3: Live API call (last resort)
+    """
+
+    def __init__(self, polygon_api, context_retriever, vector_store):
+        self.polygon = polygon_api
+        self.context_retriever = context_retriever
+        self.vector_store = vector_store
+        self.sentiment_service = get_sentiment_service(vector_store)
+        self.forecast_service = get_forecast_service()
+        self.server_cache = ToolCache(ttl_seconds=300)
+
+        # Frontend context for the current request (Layer 1)
+        self._frontend_context = {}
+        self._context_ticker = None
+
+        self._handlers = {
+            "get_stock_quote": self._get_stock_quote,
+            "get_company_info": self._get_company_info,
+            "get_financials": self._get_financials,
+            "get_news": self._get_news,
+            "search_knowledge_base": self._search_knowledge_base,
+            "analyze_sentiment": self._analyze_sentiment,
+            "get_price_forecast": self._get_price_forecast,
+            "get_dividends": self._get_dividends,
+            "get_stock_splits": self._get_stock_splits,
+            "get_price_history": self._get_price_history,
+        }
+
+    def set_context(self, frontend_context, ticker):
+        """Prime Layer 1 cache with frontend-provided data for this request."""
+        self._frontend_context = frontend_context or {}
+        self._context_ticker = ticker.upper() if ticker else None
+
+    def execute(self, tool_name, args):
+        handler = self._handlers.get(tool_name)
+        if not handler:
+            return {"error": f"Unknown tool: {tool_name}"}
+        try:
+            return handler(**args)
+        except Exception as e:
+            logger.error(f"Tool {tool_name} failed: {e}")
+            return {"error": f"Tool execution failed: {str(e)}"}
+
+    def _check_frontend_context(self, tool_name, ticker):
+        """Layer 1: Check if frontend already sent this data."""
+        if ticker.upper() != self._context_ticker:
+            return None
+
+        mapping = {
+            "get_stock_quote": "previousClose",
+            "get_company_info": "details",
+            "get_financials": "financials",
+            "get_news": "news",
+            "get_dividends": "dividends",
+            "get_stock_splits": "splits",
+            "analyze_sentiment": "sentiment",
+        }
+
+        context_key = mapping.get(tool_name)
+        if not context_key:
+            return None
+
+        overview = self._frontend_context.get("overview", {})
+
+        # Some keys are nested under overview
+        if context_key in ("previousClose", "details"):
+            data = overview.get(context_key)
+        else:
+            data = self._frontend_context.get(context_key)
+
+        return data if data else None
+
+    def _check_server_cache(self, tool_name, ticker):
+        """Layer 2: Check server-side TTL cache."""
+        return self.server_cache.get(f"{tool_name}:{ticker}")
+
+    def _cache_result(self, tool_name, ticker, result):
+        """Store result in server-side cache."""
+        self.server_cache.set(f"{tool_name}:{ticker}", result)
+
+    # -- Tool Handlers --
+
+    def _get_stock_quote(self, ticker):
+        ticker = ticker.upper()
+
+        # Layer 1: Frontend context
+        fe_data = self._check_frontend_context("get_stock_quote", ticker)
+        if fe_data:
+            results = fe_data.get("results", [])
+            if results:
+                r = results[0]
+                return {
+                    "ticker": ticker,
+                    "close": r.get("c"),
+                    "open": r.get("o"),
+                    "high": r.get("h"),
+                    "low": r.get("l"),
+                    "volume": r.get("v"),
+                    "vwap": r.get("vw"),
+                    "source": "cached"
+                }
+
+        # Layer 2: Server cache
+        cached = self._check_server_cache("get_stock_quote", ticker)
+        if cached:
+            return cached
+
+        # Layer 3: API call
+        data = self.polygon.get_previous_close(ticker)
+        results = data.get("results", [])
+        if not results:
+            return {"error": "No quote data available"}
+
+        r = results[0]
+        result = {
+            "ticker": ticker,
+            "close": r.get("c"),
+            "open": r.get("o"),
+            "high": r.get("h"),
+            "low": r.get("l"),
+            "volume": r.get("v"),
+            "vwap": r.get("vw"),
+        }
+        self._cache_result("get_stock_quote", ticker, result)
+        return result
+
+    def _get_company_info(self, ticker):
+        ticker = ticker.upper()
+
+        fe_data = self._check_frontend_context("get_company_info", ticker)
+        if fe_data:
+            r = fe_data.get("results", fe_data)
+            return {
+                "ticker": ticker,
+                "name": r.get("name"),
+                "description": r.get("description", "")[:500],
+                "market_cap": r.get("market_cap"),
+                "sector": r.get("sic_description"),
+                "homepage_url": r.get("homepage_url"),
+                "total_employees": r.get("total_employees"),
+                "source": "cached"
+            }
+
+        cached = self._check_server_cache("get_company_info", ticker)
+        if cached:
+            return cached
+
+        data = self.polygon.get_ticker_details(ticker)
+        r = data.get("results", {})
+        if not r:
+            return {"error": "No company data available"}
+
+        result = {
+            "ticker": ticker,
+            "name": r.get("name"),
+            "description": r.get("description", "")[:500],
+            "market_cap": r.get("market_cap"),
+            "sector": r.get("sic_description"),
+            "homepage_url": r.get("homepage_url"),
+            "total_employees": r.get("total_employees"),
+        }
+        self._cache_result("get_company_info", ticker, result)
+        return result
+
+    def _get_financials(self, ticker):
+        ticker = ticker.upper()
+
+        fe_data = self._check_frontend_context("get_financials", ticker)
+        if fe_data:
+            return self._format_financials(ticker, fe_data)
+
+        cached = self._check_server_cache("get_financials", ticker)
+        if cached:
+            return cached
+
+        data = self.polygon.get_financials(ticker)
+        result = self._format_financials(ticker, data)
+        self._cache_result("get_financials", ticker, result)
+        return result
+
+    def _format_financials(self, ticker, data):
+        results = data.get("results", [])
+        if not results:
+            return {"error": "No financial data available"}
+
+        periods = []
+        for r in results[:4]:
+            financials = r.get("financials", {})
+            income = financials.get("income_statement", {})
+            balance = financials.get("balance_sheet", {})
+
+            periods.append({
+                "period": f"{r.get('fiscal_period', '')} {r.get('fiscal_year', '')}",
+                "revenue": income.get("revenues", {}).get("value"),
+                "net_income": income.get("net_income_loss", {}).get("value"),
+                "gross_profit": income.get("gross_profit", {}).get("value"),
+                "total_assets": balance.get("assets", {}).get("value"),
+                "total_liabilities": balance.get("liabilities", {}).get("value"),
+            })
+
+        return {"ticker": ticker, "periods": periods}
+
+    def _get_news(self, ticker, limit=10):
+        ticker = ticker.upper()
+        limit = min(limit or 10, 20)
+
+        fe_data = self._check_frontend_context("get_news", ticker)
+        if fe_data:
+            return self._format_news(ticker, fe_data)
+
+        cached = self._check_server_cache("get_news", ticker)
+        if cached:
+            return cached
+
+        data = self.polygon.get_ticker_news(ticker, limit=limit)
+        result = self._format_news(ticker, data)
+        self._cache_result("get_news", ticker, result)
+        return result
+
+    def _format_news(self, ticker, data):
+        articles = data.get("results", data if isinstance(data, list) else [])
+        if not articles:
+            return {"error": "No news articles available"}
+
+        formatted = []
+        for a in articles[:10]:
+            formatted.append({
+                "title": a.get("title", ""),
+                "source": a.get("publisher", {}).get("name", "Unknown") if isinstance(a.get("publisher"), dict) else a.get("publisher", "Unknown"),
+                "published": a.get("published_utc", "")[:10],
+                "description": a.get("description", "")[:200],
+                "url": a.get("article_url", ""),
+            })
+
+        return {"ticker": ticker, "articles": formatted}
+
+    def _search_knowledge_base(self, query, ticker):
+        """Search FAISS vector store — no caching, always live search."""
+        ticker = ticker.upper()
+        contexts = self.context_retriever.retrieve_context(query, ticker)
+
+        if not contexts:
+            return {"message": "No relevant articles found in knowledge base. Try using get_news for recent headlines."}
+
+        results = []
+        for ctx in contexts[:5]:
+            meta = ctx["metadata"]
+            results.append({
+                "title": meta.get("title", "Untitled"),
+                "source": meta.get("source", "Unknown"),
+                "date": meta.get("published_date", "")[:10],
+                "content": meta.get("full_content", meta.get("content_preview", ""))[:500],
+                "relevance_score": round(ctx["score"], 3),
+            })
+
+        return {"ticker": ticker, "results": results}
+
+    def _analyze_sentiment(self, ticker):
+        ticker = ticker.upper()
+
+        # Layer 1: Frontend context (already-analyzed sentiment)
+        fe_data = self._check_frontend_context("analyze_sentiment", ticker)
+        if fe_data:
+            aggregate = fe_data.get("aggregate", fe_data)
+            posts = fe_data.get("posts", [])
+            return {
+                "ticker": ticker,
+                "overall_sentiment": aggregate.get("label"),
+                "score": aggregate.get("score"),
+                "confidence": aggregate.get("confidence"),
+                "post_count": aggregate.get("post_count"),
+                "sources": aggregate.get("sources", {}),
+                "top_posts": [
+                    {
+                        "platform": p.get("platform"),
+                        "content": p.get("content", "")[:200],
+                        "sentiment": p.get("sentiment", {}).get("label", p.get("sentiment_label", "")),
+                    }
+                    for p in posts[:5]
+                ],
+                "source": "cached"
+            }
+
+        cached = self._check_server_cache("analyze_sentiment", ticker)
+        if cached:
+            return cached
+
+        # Layer 3: Live scrape + analysis (slow, 10-30s)
+        data = self.sentiment_service.analyze_ticker(ticker)
+        aggregate = data.get("aggregate", {})
+        posts = data.get("posts", [])
+
+        result = {
+            "ticker": ticker,
+            "overall_sentiment": aggregate.get("label"),
+            "score": aggregate.get("score"),
+            "confidence": aggregate.get("confidence"),
+            "post_count": aggregate.get("post_count"),
+            "sources": aggregate.get("sources", {}),
+            "top_posts": [
+                {
+                    "platform": p.get("platform"),
+                    "content": p.get("content", "")[:200],
+                    "sentiment": p.get("sentiment", {}).get("label", ""),
+                }
+                for p in posts[:5]
+            ],
+        }
+        self._cache_result("analyze_sentiment", ticker, result)
+        return result
+
+    def _get_price_forecast(self, ticker):
+        ticker = ticker.upper()
+
+        cached = self._check_server_cache("get_price_forecast", ticker)
+        if cached:
+            return cached
+
+        data = self.forecast_service.get_forecast(ticker)
+        if "error" in data:
+            return {"error": data["error"]}
+
+        forecast = data.get("forecast", [])
+        result = {
+            "ticker": ticker,
+            "predictions": [
+                {
+                    "date": f.get("date"),
+                    "predicted_close": f.get("predicted_close"),
+                    "upper_bound": f.get("upper_bound"),
+                    "lower_bound": f.get("lower_bound"),
+                }
+                for f in forecast[:10]  # First 10 days to keep context manageable
+            ],
+            "model_info": data.get("model_info", {}),
+        }
+        self._cache_result("get_price_forecast", ticker, result)
+        return result
+
+    def _get_dividends(self, ticker, limit=10):
+        ticker = ticker.upper()
+
+        fe_data = self._check_frontend_context("get_dividends", ticker)
+        if fe_data:
+            return self._format_dividends(ticker, fe_data)
+
+        cached = self._check_server_cache("get_dividends", ticker)
+        if cached:
+            return cached
+
+        data = self.polygon.get_dividends(ticker, limit=limit or 10)
+        result = self._format_dividends(ticker, data)
+        self._cache_result("get_dividends", ticker, result)
+        return result
+
+    def _format_dividends(self, ticker, data):
+        results = data.get("results", data if isinstance(data, list) else [])
+        if not results:
+            return {"message": "No dividend data available for this ticker."}
+
+        formatted = []
+        for d in results[:10]:
+            formatted.append({
+                "ex_date": d.get("ex_dividend_date", ""),
+                "pay_date": d.get("pay_date", ""),
+                "amount": d.get("cash_amount"),
+                "frequency": d.get("frequency"),
+            })
+
+        return {"ticker": ticker, "dividends": formatted}
+
+    def _get_stock_splits(self, ticker):
+        ticker = ticker.upper()
+
+        fe_data = self._check_frontend_context("get_stock_splits", ticker)
+        if fe_data:
+            return self._format_splits(ticker, fe_data)
+
+        cached = self._check_server_cache("get_stock_splits", ticker)
+        if cached:
+            return cached
+
+        data = self.polygon.get_splits(ticker)
+        result = self._format_splits(ticker, data)
+        self._cache_result("get_stock_splits", ticker, result)
+        return result
+
+    def _format_splits(self, ticker, data):
+        results = data.get("results", data if isinstance(data, list) else [])
+        if not results:
+            return {"message": "No stock split history found for this ticker."}
+
+        formatted = []
+        for s in results[:10]:
+            formatted.append({
+                "execution_date": s.get("execution_date", ""),
+                "split_from": s.get("split_from"),
+                "split_to": s.get("split_to"),
+                "ratio": f"{s.get('split_to', 1)}-for-{s.get('split_from', 1)}",
+            })
+
+        return {"ticker": ticker, "splits": formatted}
+
+    def _get_price_history(self, ticker, from_date, to_date, timespan=None):
+        ticker = ticker.upper()
+        timespan = timespan or "day"
+
+        cache_key = f"get_price_history:{ticker}:{from_date}:{to_date}:{timespan}"
+        cached = self.server_cache.get(cache_key)
+        if cached:
+            return cached
+
+        data = self.polygon.get_aggregates(ticker, timespan=timespan, from_date=from_date, to_date=to_date)
+        results = data.get("results", [])
+        if not results:
+            return {"error": "No price history available for the given date range"}
+
+        formatted = []
+        for bar in results:
+            formatted.append({
+                "date": datetime.fromtimestamp(bar["t"] / 1000).strftime("%Y-%m-%d"),
+                "open": bar.get("o"),
+                "high": bar.get("h"),
+                "low": bar.get("l"),
+                "close": bar.get("c"),
+                "volume": bar.get("v"),
+            })
+
+        result = {
+            "ticker": ticker,
+            "timespan": timespan,
+            "from": from_date,
+            "to": to_date,
+            "bars": formatted,
+            "count": len(formatted),
+        }
+        self.server_cache.set(cache_key, result)
+        return result

be/app.py

@@ -0,0 +1,127 @@
+from flask import Flask, jsonify, request, send_from_directory
+from flask_cors import CORS
+from polygon_api import PolygonAPI
+from chat_routes import register_chat_routes
+from sentiment_routes import sentiment_bp
+from forecast_routes import forecast_bp
+import os
+import atexit
+
+app = Flask(__name__, static_folder='../fe', static_url_path='')
+CORS(app)
+
+polygon = PolygonAPI()
+
+@app.route('/')
+def index():
+    return send_from_directory(app.static_folder, 'index.html')
+
+@app.route('/company_tickers.json')
+def get_tickers():
+    return send_from_directory('../', 'company_tickers.json')
+
+@app.route('/api/ticker/<ticker>/details', methods=['GET'])
+def get_ticker_details(ticker):
+    try:
+        data = polygon.get_ticker_details(ticker.upper())
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/ticker/<ticker>/previous-close', methods=['GET'])
+def get_previous_close(ticker):
+    try:
+        data = polygon.get_previous_close(ticker.upper())
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/ticker/<ticker>/aggregates', methods=['GET'])
+def get_aggregates(ticker):
+    try:
+        from_date = request.args.get('from')
+        to_date = request.args.get('to')
+        timespan = request.args.get('timespan', 'day')
+
+        data = polygon.get_aggregates(ticker.upper(), timespan, from_date, to_date)
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/ticker/<ticker>/news', methods=['GET'])
+def get_news(ticker):
+    try:
+        limit = request.args.get('limit', 10, type=int)
+        data = polygon.get_ticker_news(ticker.upper(), limit)
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/ticker/<ticker>/financials', methods=['GET'])
+def get_financials(ticker):
+    try:
+        data = polygon.get_financials(ticker.upper())
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/ticker/<ticker>/snapshot', methods=['GET'])
+def get_snapshot(ticker):
+    try:
+        data = polygon.get_snapshot(ticker.upper())
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/ticker/<ticker>/dividends', methods=['GET'])
+def get_dividends(ticker):
+    try:
+        limit = request.args.get('limit', 10, type=int)
+        data = polygon.get_dividends(ticker.upper(), limit)
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/ticker/<ticker>/splits', methods=['GET'])
+def get_splits(ticker):
+    try:
+        limit = request.args.get('limit', 10, type=int)
+        data = polygon.get_splits(ticker.upper(), limit)
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/market-status', methods=['GET'])
+def get_market_status():
+    try:
+        data = polygon.get_market_status()
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# Register chat routes
+register_chat_routes(app)
+
+# Register sentiment routes
+app.register_blueprint(sentiment_bp)
+
+# Register forecast routes
+app.register_blueprint(forecast_bp)
+
+# Graceful shutdown handler for FAISS
+from chat_routes import agent_service
+
+def shutdown_handler():
+    """Save FAISS index on graceful shutdown"""
+    print("Shutting down gracefully, saving FAISS index...")
+    try:
+        agent_service.vector_store.save()
+        print("FAISS index saved successfully")
+    except Exception as e:
+        print(f"Error saving FAISS index on shutdown: {e}")
+
+atexit.register(shutdown_handler)
+
+if __name__ == '__main__':
+    from config import PORT
+    app.run(debug=False, port=PORT)

be/chat_routes.py

@@ -0,0 +1,204 @@
+from flask import request, jsonify, Response, stream_with_context
+from agent_service import AgentService
+import json
+
+# Initialize agent service
+agent_service = AgentService()
+
+
+def format_sse(event_type, data):
+    """Format a Server-Sent Event."""
+    if isinstance(data, dict):
+        data_str = json.dumps(data)
+    else:
+        data_str = str(data)
+    return f"event: {event_type}\ndata: {data_str}\n\n"
+
+
+def register_chat_routes(app):
+    """Register chat-related routes with Flask app"""
+
+    @app.route('/api/chat/message', methods=['POST'])
+    def chat_message():
+        """
+        Main chat endpoint - processes user messages via agent and streams responses
+
+        Request body:
+        {
+            "ticker": "AAPL",
+            "message": "What's the latest news?",
+            "context": {
+                "overview": {...},
+                "financials": {...},
+                "news": [...],
+                ...
+            },
+            "conversation_id": "uuid"
+        }
+
+        Response: Server-Sent Events stream with typed events:
+          event: tool_call  - Agent is calling a tool
+          event: text       - Response text chunk
+          event: done       - Stream complete
+          event: error      - Error occurred
+        """
+        try:
+            data = request.get_json()
+
+            ticker = data.get('ticker')
+            message = data.get('message')
+            context = data.get('context', {})
+            conversation_id = data.get('conversation_id', 'default')
+
+            if not ticker or not message:
+                return jsonify({"error": "Missing required fields"}), 400
+
+            def generate():
+                """Generator for structured SSE streaming."""
+                try:
+                    for event_type, event_data in agent_service.process_message(
+                        ticker=ticker,
+                        message=message,
+                        frontend_context=context,
+                        conversation_id=conversation_id
+                    ):
+                        yield format_sse(event_type, event_data)
+                except Exception as e:
+                    print(f"Error in stream: {e}")
+                    yield format_sse("error", {"message": str(e)})
+
+            return Response(
+                stream_with_context(generate()),
+                mimetype='text/event-stream',
+                headers={
+                    'Cache-Control': 'no-cache',
+                    'X-Accel-Buffering': 'no'
+                }
+            )
+
+        except Exception as e:
+            print(f"Error in chat_message: {e}")
+            return jsonify({"error": str(e)}), 500
+
+    @app.route('/api/chat/scrape-articles', methods=['POST'])
+    def scrape_articles():
+        """
+        Background job to scrape and embed articles
+
+        Request body:
+        {
+            "ticker": "AAPL",
+            "articles": [...]
+        }
+
+        Response:
+        {
+            "scraped": 8,
+            "embedded": 8,
+            "failed": 2,
+            "skipped": 5
+        }
+        """
+        try:
+            data = request.get_json()
+
+            ticker = data.get('ticker')
+            articles = data.get('articles', [])
+
+            if not ticker:
+                return jsonify({"error": "Missing ticker"}), 400
+
+            if not articles:
+                return jsonify({
+                    "scraped": 0,
+                    "embedded": 0,
+                    "failed": 0,
+                    "skipped": 0,
+                    "message": "No articles provided"
+                }), 200
+
+            results = agent_service.scrape_and_embed_articles(ticker, articles)
+
+            return jsonify(results), 200
+
+        except Exception as e:
+            print(f"Error in scrape_articles: {e}")
+            return jsonify({"error": str(e)}), 500
+
+    @app.route('/api/chat/conversations/<conversation_id>', methods=['GET'])
+    def get_conversation(conversation_id):
+        """Get conversation history"""
+        try:
+            history = agent_service.conversation_manager.get_history(conversation_id)
+            return jsonify({"messages": history}), 200
+        except Exception as e:
+            print(f"Error in get_conversation: {e}")
+            return jsonify({"error": str(e)}), 500
+
+    @app.route('/api/chat/clear/<conversation_id>', methods=['DELETE'])
+    def clear_conversation(conversation_id):
+        """Clear conversation history"""
+        try:
+            agent_service.conversation_manager.clear_conversation(conversation_id)
+            return jsonify({"success": True}), 200
+        except Exception as e:
+            print(f"Error in clear_conversation: {e}")
+            return jsonify({"error": str(e)}), 500
+
+    @app.route('/api/chat/health', methods=['GET'])
+    def chat_health():
+        """Health check endpoint for chat service"""
+        try:
+            return jsonify({
+                "status": "healthy",
+                "components": {
+                    "agent": "ok",
+                    "embeddings": "ok",
+                    "vector_store": "ok",
+                    "llm": "ok"
+                }
+            }), 200
+        except Exception as e:
+            return jsonify({"status": "unhealthy", "error": str(e)}), 500
+
+    @app.route('/api/chat/debug/chunks', methods=['GET'])
+    def debug_chunks():
+        """Debug endpoint to view all stored RAG chunks"""
+        try:
+            ticker_filter = request.args.get('ticker')
+            limit = int(request.args.get('limit', 50))
+
+            vector_store = agent_service.vector_store
+            all_metadata = vector_store.metadata
+
+            chunks = []
+            for internal_id, meta in all_metadata.items():
+                if ticker_filter and meta.get('ticker') != ticker_filter:
+                    continue
+
+                chunks.append({
+                    "id": internal_id,
+                    "doc_id": meta.get('doc_id', ''),
+                    "ticker": meta.get('ticker', ''),
+                    "type": meta.get('type', ''),
+                    "title": meta.get('title', ''),
+                    "url": meta.get('url', ''),
+                    "source": meta.get('source', ''),
+                    "published_date": meta.get('published_date', ''),
+                    "content_preview": meta.get('content_preview', ''),
+                    "full_content": meta.get('full_content', '')
+                })
+
+                if len(chunks) >= limit:
+                    break
+
+            return jsonify({
+                "total": len(all_metadata),
+                "returned": len(chunks),
+                "index_stats": vector_store.get_stats(),
+                "chunks": chunks
+            }), 200
+
+        except Exception as e:
+            print(f"Error in debug_chunks: {e}")
+            return jsonify({"error": str(e)}), 500

be/chat_service.py

@@ -0,0 +1,385 @@
+from scraper import ArticleScraper
+from rag_pipeline import EmbeddingGenerator, VectorStore, ContextRetriever
+from llm_client import GeminiClient, ConversationManager
+import concurrent.futures
+import hashlib
+
+
+class ChatService:
+    """Orchestrates chatbot components: scraping, RAG, and LLM"""
+
+    def __init__(self):
+        self.scraper = ArticleScraper()
+        self.embedding_gen = EmbeddingGenerator()
+        self.vector_store = VectorStore()
+        self.context_retriever = ContextRetriever(vector_store=self.vector_store)
+        self.llm_client = GeminiClient()
+        self.conversation_manager = ConversationManager()
+
+    def process_message(self, ticker, message, frontend_context, conversation_id):
+        """
+        Process a user message and generate a response
+
+        Args:
+            ticker: Stock ticker symbol
+            message: User message
+            frontend_context: Context from frontend (overview, financials, news, etc.)
+            conversation_id: Unique conversation identifier
+
+        Yields:
+            Response chunks for streaming
+        """
+        try:
+            # Build comprehensive context
+            prompt = self._assemble_prompt(
+                query=message,
+                ticker=ticker,
+                frontend_context=frontend_context,
+                conversation_id=conversation_id
+            )
+
+            # Get conversation history
+            history = self.conversation_manager.get_history(conversation_id)
+
+            # Stream response from LLM
+            full_response = ""
+            for chunk in self.llm_client.stream_response(prompt, history):
+                full_response += chunk
+                yield chunk
+
+            # Save to conversation history
+            self.conversation_manager.add_message(conversation_id, 'user', message)
+            self.conversation_manager.add_message(conversation_id, 'assistant', full_response)
+
+        except Exception as e:
+            print(f"Error processing message: {e}")
+            yield "I encountered an error processing your request. Please try again."
+
+    def scrape_and_embed_articles(self, ticker, articles):
+        """
+        Background job to scrape and embed news articles
+
+        Args:
+            ticker: Stock ticker symbol
+            articles: List of article metadata from Polygon API
+
+        Returns:
+            Dictionary with scraping statistics
+        """
+        results = {
+            "scraped": 0,
+            "embedded": 0,
+            "failed": 0,
+            "skipped": 0
+        }
+
+        def process_article(article):
+            """Process a single article"""
+            try:
+                # Generate unique document ID
+                article_url = article.get('article_url', '')
+                doc_id = f"{ticker}_news_{self._hash_url(article_url)}"
+
+                # Check if already processed
+                if self.vector_store.document_exists(doc_id):
+                    return {'status': 'skipped'}
+
+                # Scrape full content
+                content = self.scraper.scrape_article(article_url)
+
+                if not content:
+                    # Fall back to article description if scraping fails
+                    content = article.get('description', '')
+                    if not content or len(content) < 50:
+                        return {'status': 'failed'}
+
+                # Generate embedding
+                embedding = self.embedding_gen.generate_embedding(content)
+
+                if not embedding:
+                    return {'status': 'failed'}
+
+                # Prepare metadata
+                metadata = {
+                    "ticker": ticker,
+                    "type": "news_article",
+                    "title": article.get('title', ''),
+                    "url": article_url,
+                    "published_date": article.get('published_utc', ''),
+                    "source": article.get('publisher', {}).get('name', 'Unknown'),
+                    "content_preview": content[:200],
+                    "full_content": content  # Store full content in metadata
+                }
+
+                # Store in FAISS
+                success = self.vector_store.upsert_document(doc_id, embedding, metadata)
+
+                if success:
+                    return {'status': 'embedded'}
+                else:
+                    return {'status': 'failed'}
+
+            except Exception as e:
+                print(f"Error processing article: {e}")
+                return {'status': 'failed'}
+
+        # Process articles in parallel
+        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+            futures = [executor.submit(process_article, article) for article in articles[:20]]  # Limit to 20 articles
+
+            for future in concurrent.futures.as_completed(futures):
+                result = future.result()
+                status = result.get('status', 'failed')
+
+                if status == 'embedded':
+                    results['embedded'] += 1
+                    results['scraped'] += 1
+                elif status == 'skipped':
+                    results['skipped'] += 1
+                elif status == 'failed':
+                    results['failed'] += 1
+
+        # Save FAISS index after batch operations
+        if results['embedded'] > 0:
+            self.vector_store.save()
+
+        return results
+
+    def _assemble_prompt(self, query, ticker, frontend_context, conversation_id):
+        """
+        Assemble comprehensive prompt with all context
+
+        Args:
+            query: User query
+            ticker: Stock ticker
+            frontend_context: Data from frontend
+            conversation_id: Conversation ID
+
+        Returns:
+            Complete prompt string
+        """
+        prompt_parts = []
+
+        # Add current stock overview
+        overview = frontend_context.get('overview', {})
+        if overview:
+            prompt_parts.append(self._format_overview(ticker, overview))
+
+        # Retrieve relevant context from RAG
+        rag_contexts = self.context_retriever.retrieve_context(query, ticker)
+        if rag_contexts:
+            prompt_parts.append(self._format_rag_contexts(rag_contexts))
+
+        # Add financials if relevant to query
+        if any(keyword in query.lower() for keyword in ['revenue', 'profit', 'income', 'earnings', 'financial', 'balance']):
+            financials = frontend_context.get('financials')
+            if financials:
+                prompt_parts.append(self._format_financials(financials))
+
+        # Add dividends if relevant
+        if 'dividend' in query.lower():
+            dividends = frontend_context.get('dividends')
+            if dividends:
+                prompt_parts.append(self._format_dividends(dividends))
+
+        # Add splits if relevant
+        if 'split' in query.lower():
+            splits = frontend_context.get('splits')
+            if splits:
+                prompt_parts.append(self._format_splits(splits))
+
+        # Add sentiment if relevant to query
+        sentiment_keywords = ['sentiment', 'bullish', 'bearish', 'feel', 'opinion',
+                             'mood', 'social', 'twitter', 'reddit', 'stocktwits', 'buzz']
+        if any(keyword in query.lower() for keyword in sentiment_keywords):
+            # Retrieve sentiment posts from RAG
+            sentiment_contexts = self._retrieve_sentiment_context(query, ticker)
+            if sentiment_contexts:
+                prompt_parts.append(self._format_sentiment_contexts(sentiment_contexts))
+
+            # Include aggregate sentiment from frontend if available
+            sentiment_data = frontend_context.get('sentiment')
+            if sentiment_data:
+                prompt_parts.append(self._format_aggregate_sentiment(sentiment_data))
+
+        # Combine all context
+        context_str = "\n\n---\n\n".join(prompt_parts) if prompt_parts else "No additional context available."
+
+        # Final prompt
+        full_prompt = f"""Context Information:
+{context_str}
+
+---
+
+User Question: {query}
+
+Please provide a data-driven answer based on the context above."""
+
+        return full_prompt
+
+    def _format_overview(self, ticker, overview):
+        """Format stock overview data"""
+        details = overview.get('details', {}).get('results', {})
+        prev_close = overview.get('previousClose', {}).get('results', [{}])[0]
+
+        company_name = details.get('name', ticker)
+        description = details.get('description', 'No description available')[:300]
+        market_cap = details.get('market_cap', 0)
+
+        close_price = prev_close.get('c', 0)
+        volume = prev_close.get('v', 0)
+        high = prev_close.get('h', 0)
+        low = prev_close.get('l', 0)
+
+        return f"""Stock Overview for {ticker} - {company_name}:
+- Current Price: ${close_price:,.2f}
+- Market Cap: ${market_cap:,.0f}
+- Volume: {volume:,.0f}
+- Day High: ${high:,.2f}
+- Day Low: ${low:,.2f}
+- Description: {description}"""
+
+    def _format_rag_contexts(self, contexts):
+        """Format RAG retrieved contexts"""
+        if not contexts:
+            return ""
+
+        formatted = ["Relevant News Articles:"]
+
+        for ctx in contexts[:5]:  # Top 5 results
+            metadata = ctx['metadata']
+            title = metadata.get('title', 'Untitled')
+            source = metadata.get('source', 'Unknown')
+            date = metadata.get('published_date', '')[:10]  # Just the date
+            content = metadata.get('full_content', metadata.get('content_preview', ''))[:500]  # First 500 chars
+
+            formatted.append(f"\n- {title} ({source}, {date})")
+            formatted.append(f"  Content: {content}...")
+
+        return "\n".join(formatted)
+
+    def _format_financials(self, financials):
+        """Format financial data"""
+        results = financials.get('results', [])
+        if not results:
+            return ""
+
+        formatted = ["Recent Financial Data:"]
+
+        for result in results[:4]:  # Last 4 quarters/years
+            fiscal_period = result.get('fiscal_period', '')
+            fiscal_year = result.get('fiscal_year', '')
+
+            financials_data = result.get('financials', {})
+            income_statement = financials_data.get('income_statement', {})
+            balance_sheet = financials_data.get('balance_sheet', {})
+
+            revenue = income_statement.get('revenues', {}).get('value', 0)
+            net_income = income_statement.get('net_income_loss', {}).get('value', 0)
+            assets = balance_sheet.get('assets', {}).get('value', 0)
+
+            formatted.append(f"\n{fiscal_period} {fiscal_year}:")
+            formatted.append(f"  - Revenue: ${revenue:,.0f}")
+            formatted.append(f"  - Net Income: ${net_income:,.0f}")
+            formatted.append(f"  - Total Assets: ${assets:,.0f}")
+
+        return "\n".join(formatted)
+
+    def _format_dividends(self, dividends):
+        """Format dividend data"""
+        results = dividends.get('results', [])
+        if not results:
+            return ""
+
+        formatted = ["Recent Dividends:"]
+
+        for div in results[:5]:
+            ex_date = div.get('ex_dividend_date', '')
+            amount = div.get('cash_amount', 0)
+            formatted.append(f"- {ex_date}: ${amount:.2f} per share")
+
+        return "\n".join(formatted)
+
+    def _format_splits(self, splits):
+        """Format stock split data"""
+        results = splits.get('results', [])
+        if not results:
+            return ""
+
+        formatted = ["Stock Splits:"]
+
+        for split in results[:5]:
+            execution_date = split.get('execution_date', '')
+            split_from = split.get('split_from', 1)
+            split_to = split.get('split_to', 1)
+            formatted.append(f"- {execution_date}: {split_to}-for-{split_from} split")
+
+        return "\n".join(formatted)
+
+    def _hash_url(self, url):
+        """Generate a short hash for URL"""
+        return hashlib.md5(url.encode()).hexdigest()[:12]
+
+    def _retrieve_sentiment_context(self, query, ticker):
+        """Retrieve sentiment posts from FAISS"""
+        try:
+            query_embedding = self.embedding_gen.generate_query_embedding(query)
+            if not query_embedding:
+                return []
+
+            matches = self.vector_store.search(
+                query_embedding=query_embedding,
+                ticker=ticker,
+                namespace="sentiment",
+                top_k=5
+            )
+
+            contexts = []
+            for match in matches:
+                contexts.append({
+                    'score': match.score,
+                    'metadata': match.metadata,
+                    'id': match.id
+                })
+
+            return contexts
+        except Exception as e:
+            print(f"Error retrieving sentiment context: {e}")
+            return []
+
+    def _format_sentiment_contexts(self, contexts):
+        """Format sentiment posts from RAG"""
+        if not contexts:
+            return ""
+
+        formatted = ["Relevant Social Media Posts:"]
+
+        for ctx in contexts[:5]:
+            metadata = ctx['metadata']
+            platform = metadata.get('platform', 'unknown')
+            sentiment = metadata.get('sentiment_label', 'neutral')
+            content = metadata.get('full_content', metadata.get('content', ''))[:300]
+            author = metadata.get('author', 'unknown')
+            likes = metadata.get('likes', 0)
+
+            formatted.append(f"\n- [{platform.upper()}] @{author} ({sentiment}, {likes} likes)")
+            formatted.append(f"  \"{content}...\"")
+
+        return "\n".join(formatted)
+
+    def _format_aggregate_sentiment(self, sentiment_data):
+        """Format aggregate sentiment data from frontend"""
+        aggregate = sentiment_data.get('aggregate', {})
+        if not aggregate:
+            return ""
+
+        label = aggregate.get('label', 'neutral')
+        score = aggregate.get('score', 0)
+        confidence = aggregate.get('confidence', 0)
+        post_count = aggregate.get('post_count', 0)
+        sources = aggregate.get('sources', {})
+
+        return f"""Current Social Media Sentiment:
+- Overall: {label.upper()} (score: {score:.2f}, confidence: {confidence:.0%})
+- Posts analyzed: {post_count}
+- Sources: StockTwits ({sources.get('stocktwits', 0)}), Reddit ({sources.get('reddit', 0)}), Twitter ({sources.get('twitter', 0)})"""

be/config.py

@@ -0,0 +1,36 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Existing
+POLYGON_API_KEY = os.getenv('POLYGON_API_KEY', '')
+PORT = int(os.getenv('PORT', 5000))
+
+# Gemini configuration (for chat and embeddings - FREE)
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY', '')
+GEMINI_MODEL = os.getenv('GEMINI_MODEL', 'gemini-2.0-flash')
+
+# FAISS configuration (path relative to this file's location)
+FAISS_INDEX_PATH = os.getenv('FAISS_INDEX_PATH',
+    os.path.join(os.path.dirname(__file__), 'faiss_index'))
+
+# Embedding settings (using Google's free embedding model)
+EMBEDDING_MODEL = os.getenv('EMBEDDING_MODEL', 'gemini-embedding-001')
+MAX_CONTEXT_LENGTH = int(os.getenv('MAX_CONTEXT_LENGTH', 8000))
+RAG_TOP_K = int(os.getenv('RAG_TOP_K', 5))
+
+# Sentiment Analysis configuration
+FINBERT_MODEL = os.getenv('FINBERT_MODEL', 'ProsusAI/finbert')
+SENTIMENT_CACHE_TTL = int(os.getenv('SENTIMENT_CACHE_TTL', 15))  # minutes
+
+# Reddit API (free - get credentials at reddit.com/prefs/apps)
+REDDIT_CLIENT_ID = os.getenv('REDDIT_CLIENT_ID', '')
+REDDIT_CLIENT_SECRET = os.getenv('REDDIT_CLIENT_SECRET', '')
+REDDIT_USER_AGENT = os.getenv('REDDIT_USER_AGENT', 'StockAssistant/1.0')
+
+# Twitter API (optional - requires paid tier $100+/month)
+TWITTER_BEARER_TOKEN = os.getenv('TWITTER_BEARER_TOKEN', '')
+
+# Agent configuration
+AGENT_MAX_ITERATIONS = int(os.getenv('AGENT_MAX_ITERATIONS', 5))

be/forecast_model.py

@@ -0,0 +1,410 @@
+"""
+LSTM-based stock price forecaster.
+Uses historical OHLCV data to predict future closing prices.
+"""
+
+import torch
+import torch.nn as nn
+import numpy as np
+import pickle
+import json
+import os
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class LSTMModel(nn.Module):
+    """LSTM neural network for time series forecasting."""
+
+    def __init__(self, input_size: int = 5, hidden_size: int = 128,
+                 num_layers: int = 2, output_size: int = 30, dropout: float = 0.2):
+        super(LSTMModel, self).__init__()
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+
+        self.lstm = nn.LSTM(
+            input_size=input_size,
+            hidden_size=hidden_size,
+            num_layers=num_layers,
+            batch_first=True,
+            dropout=dropout if num_layers > 1 else 0
+        )
+
+        self.fc = nn.Sequential(
+            nn.Linear(hidden_size, 64),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(64, output_size)
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # x shape: (batch, seq_len, input_size)
+        lstm_out, _ = self.lstm(x)
+        # Take the last output
+        last_output = lstm_out[:, -1, :]
+        # Predict future prices
+        predictions = self.fc(last_output)
+        return predictions
+
+
+class MinMaxScaler:
+    """Simple MinMax scaler for normalization."""
+
+    def __init__(self):
+        self.min_vals = None
+        self.max_vals = None
+        self.fitted = False
+
+    def fit(self, data: np.ndarray) -> 'MinMaxScaler':
+        self.min_vals = data.min(axis=0)
+        self.max_vals = data.max(axis=0)
+        # Avoid division by zero
+        self.range_vals = self.max_vals - self.min_vals
+        self.range_vals[self.range_vals == 0] = 1
+        self.fitted = True
+        return self
+
+    def transform(self, data: np.ndarray) -> np.ndarray:
+        if not self.fitted:
+            raise ValueError("Scaler not fitted. Call fit() first.")
+        return (data - self.min_vals) / self.range_vals
+
+    def fit_transform(self, data: np.ndarray) -> np.ndarray:
+        self.fit(data)
+        return self.transform(data)
+
+    def inverse_transform(self, data: np.ndarray, col_idx: int = 0) -> np.ndarray:
+        """Inverse transform for a single column (default: close price at index 0)."""
+        if not self.fitted:
+            raise ValueError("Scaler not fitted. Call fit() first.")
+        return data * self.range_vals[col_idx] + self.min_vals[col_idx]
+
+
+class StockForecaster:
+    """
+    Stock price forecaster using LSTM neural network.
+
+    The model is lazy-loaded on first use to avoid slow startup times.
+    Supports training on historical OHLCV data and predicting future prices.
+    """
+
+    MODEL_DIR = os.path.join(os.path.dirname(__file__), 'forecast_models')
+
+    def __init__(self, sequence_length: int = 60, forecast_horizon: int = 30):
+        self._models: Dict[str, LSTMModel] = {}
+        self._scalers: Dict[str, MinMaxScaler] = {}
+        self._device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.sequence_length = sequence_length
+        self.forecast_horizon = forecast_horizon
+
+        # Ensure model directory exists
+        os.makedirs(self.MODEL_DIR, exist_ok=True)
+
+    def _get_ticker_dir(self, ticker: str) -> str:
+        """Get the directory path for a ticker's model files."""
+        return os.path.join(self.MODEL_DIR, ticker.upper())
+
+    def _load_model(self, ticker: str) -> bool:
+        """
+        Load a trained model for a ticker from disk.
+
+        Returns:
+            True if model was loaded successfully, False otherwise.
+        """
+        ticker = ticker.upper()
+        if ticker in self._models:
+            return True
+
+        ticker_dir = self._get_ticker_dir(ticker)
+        model_path = os.path.join(ticker_dir, 'model.pt')
+        scaler_path = os.path.join(ticker_dir, 'scaler.pkl')
+
+        if not os.path.exists(model_path) or not os.path.exists(scaler_path):
+            return False
+
+        try:
+            logger.info(f"Loading forecast model for {ticker}...")
+
+            # Load scaler
+            with open(scaler_path, 'rb') as f:
+                self._scalers[ticker] = pickle.load(f)
+
+            # Build and load model
+            model = LSTMModel(output_size=self.forecast_horizon)
+            model.load_state_dict(torch.load(model_path, map_location=self._device, weights_only=True))
+            model.to(self._device)
+            model.eval()
+            self._models[ticker] = model
+
+            logger.info(f"Forecast model for {ticker} loaded successfully on {self._device}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to load forecast model for {ticker}: {e}")
+            return False
+
+    def _save_model(self, ticker: str, metadata: Dict) -> None:
+        """Save trained model and scaler to disk."""
+        ticker = ticker.upper()
+        ticker_dir = self._get_ticker_dir(ticker)
+        os.makedirs(ticker_dir, exist_ok=True)
+
+        model_path = os.path.join(ticker_dir, 'model.pt')
+        scaler_path = os.path.join(ticker_dir, 'scaler.pkl')
+        metadata_path = os.path.join(ticker_dir, 'metadata.json')
+
+        # Save model weights
+        torch.save(self._models[ticker].state_dict(), model_path)
+
+        # Save scaler
+        with open(scaler_path, 'wb') as f:
+            pickle.dump(self._scalers[ticker], f)
+
+        # Save metadata
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f, indent=2)
+
+        logger.info(f"Forecast model for {ticker} saved to {ticker_dir}")
+
+    def _prepare_data(self, data: List[Dict]) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Prepare OHLCV data for training.
+
+        Args:
+            data: List of dicts with keys: o, h, l, c, v (open, high, low, close, volume)
+
+        Returns:
+            Tuple of (X, y) numpy arrays for training
+        """
+        # Extract OHLCV features - close first for easy inverse transform
+        features = np.array([[d['c'], d['o'], d['h'], d['l'], d['v']] for d in data], dtype=np.float32)
+
+        # Create sequences
+        X, y = [], []
+        for i in range(len(features) - self.sequence_length - self.forecast_horizon + 1):
+            X.append(features[i:i + self.sequence_length])
+            # Target: next forecast_horizon closing prices
+            y.append(features[i + self.sequence_length:i + self.sequence_length + self.forecast_horizon, 0])
+
+        return np.array(X), np.array(y)
+
+    def train(self, ticker: str, data: List[Dict], epochs: int = 50,
+              learning_rate: float = 0.001, batch_size: int = 32) -> Dict:
+        """
+        Train the LSTM model on historical price data.
+
+        Args:
+            ticker: Stock ticker symbol
+            data: List of OHLCV dicts (must have at least sequence_length + forecast_horizon entries)
+            epochs: Number of training epochs
+            learning_rate: Learning rate for optimizer
+            batch_size: Training batch size
+
+        Returns:
+            Dict with training results (loss, metadata)
+        """
+        ticker = ticker.upper()
+
+        if len(data) < self.sequence_length + self.forecast_horizon:
+            raise ValueError(f"Insufficient data: need at least {self.sequence_length + self.forecast_horizon} data points")
+
+        logger.info(f"Training forecast model for {ticker} with {len(data)} data points...")
+
+        # Prepare data
+        X, y = self._prepare_data(data)
+
+        # Normalize features
+        scaler = MinMaxScaler()
+        X_flat = X.reshape(-1, X.shape[-1])
+        scaler.fit(X_flat)
+        X_scaled = np.array([scaler.transform(seq) for seq in X])
+
+        # Normalize targets using close price stats
+        y_scaled = (y - scaler.min_vals[0]) / scaler.range_vals[0]
+
+        self._scalers[ticker] = scaler
+
+        # Convert to tensors
+        X_tensor = torch.FloatTensor(X_scaled).to(self._device)
+        y_tensor = torch.FloatTensor(y_scaled).to(self._device)
+
+        # Split train/validation (80/20)
+        split_idx = int(len(X_tensor) * 0.8)
+        X_train, X_val = X_tensor[:split_idx], X_tensor[split_idx:]
+        y_train, y_val = y_tensor[:split_idx], y_tensor[split_idx:]
+
+        # Build model
+        model = LSTMModel(output_size=self.forecast_horizon)
+        model.to(self._device)
+
+        criterion = nn.MSELoss()
+        optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+
+        # Training loop
+        best_val_loss = float('inf')
+        train_losses = []
+
+        for epoch in range(epochs):
+            model.train()
+            epoch_loss = 0
+
+            # Mini-batch training
+            for i in range(0, len(X_train), batch_size):
+                batch_X = X_train[i:i + batch_size]
+                batch_y = y_train[i:i + batch_size]
+
+                optimizer.zero_grad()
+                outputs = model(batch_X)
+                loss = criterion(outputs, batch_y)
+                loss.backward()
+                optimizer.step()
+
+                epoch_loss += loss.item()
+
+            avg_train_loss = epoch_loss / (len(X_train) // batch_size + 1)
+            train_losses.append(avg_train_loss)
+
+            # Validation
+            model.eval()
+            with torch.no_grad():
+                val_outputs = model(X_val)
+                val_loss = criterion(val_outputs, y_val).item()
+
+            if val_loss < best_val_loss:
+                best_val_loss = val_loss
+
+            if (epoch + 1) % 10 == 0:
+                logger.info(f"Epoch {epoch + 1}/{epochs} - Train Loss: {avg_train_loss:.6f}, Val Loss: {val_loss:.6f}")
+
+        self._models[ticker] = model
+
+        # Save model and metadata
+        metadata = {
+            "ticker": ticker,
+            "trained_at": datetime.utcnow().isoformat() + "Z",
+            "training_epochs": epochs,
+            "final_train_loss": float(train_losses[-1]),
+            "final_val_loss": float(best_val_loss),
+            "data_points": len(data),
+            "sequence_length": self.sequence_length,
+            "forecast_horizon": self.forecast_horizon,
+            "model_version": "1.0"
+        }
+
+        self._save_model(ticker, metadata)
+
+        logger.info(f"Training complete for {ticker}. Final val loss: {best_val_loss:.6f}")
+
+        return {
+            "status": "training_complete",
+            "ticker": ticker,
+            "epochs": epochs,
+            "final_loss": float(train_losses[-1]),
+            "validation_loss": float(best_val_loss),
+            "data_points": len(data)
+        }
+
+    def predict(self, ticker: str, recent_data: List[Dict]) -> Dict:
+        """
+        Generate price forecast using trained model.
+
+        Args:
+            ticker: Stock ticker symbol
+            recent_data: Most recent OHLCV data (at least sequence_length entries)
+
+        Returns:
+            Dict with predictions and confidence bounds
+        """
+        ticker = ticker.upper()
+
+        # Load model if not in memory
+        if ticker not in self._models:
+            if not self._load_model(ticker):
+                raise ValueError(f"No trained model found for {ticker}. Train the model first.")
+
+        if len(recent_data) < self.sequence_length:
+            raise ValueError(f"Need at least {self.sequence_length} data points for prediction")
+
+        # Use last sequence_length data points
+        data = recent_data[-self.sequence_length:]
+        features = np.array([[d['c'], d['o'], d['h'], d['l'], d['v']] for d in data], dtype=np.float32)
+
+        # Normalize
+        scaler = self._scalers[ticker]
+        features_scaled = scaler.transform(features)
+
+        # Predict
+        model = self._models[ticker]
+        model.eval()
+
+        X = torch.FloatTensor(features_scaled).unsqueeze(0).to(self._device)
+
+        with torch.no_grad():
+            predictions_scaled = model(X).cpu().numpy()[0]
+
+        # Inverse transform predictions
+        predictions = scaler.inverse_transform(predictions_scaled, col_idx=0)
+
+        # Calculate confidence bounds (simple approach: +/- percentage based on historical volatility)
+        recent_closes = [d['c'] for d in recent_data[-30:]]
+        volatility = np.std(recent_closes) / np.mean(recent_closes)
+        confidence_pct = max(0.02, min(0.10, volatility * 2))  # 2-10% bounds
+
+        upper_bound = predictions * (1 + confidence_pct)
+        lower_bound = predictions * (1 - confidence_pct)
+
+        # Get last date from data for generating forecast dates
+        last_timestamp = recent_data[-1].get('t', 0)
+
+        return {
+            "predictions": predictions.tolist(),
+            "upper_bound": upper_bound.tolist(),
+            "lower_bound": lower_bound.tolist(),
+            "last_timestamp": last_timestamp,
+            "forecast_horizon": self.forecast_horizon
+        }
+
+    def has_model(self, ticker: str) -> bool:
+        """Check if a trained model exists for the ticker."""
+        ticker = ticker.upper()
+        if ticker in self._models:
+            return True
+
+        ticker_dir = self._get_ticker_dir(ticker)
+        return os.path.exists(os.path.join(ticker_dir, 'model.pt'))
+
+    def get_model_metadata(self, ticker: str) -> Optional[Dict]:
+        """Get metadata for a trained model."""
+        ticker = ticker.upper()
+        metadata_path = os.path.join(self._get_ticker_dir(ticker), 'metadata.json')
+
+        if not os.path.exists(metadata_path):
+            return None
+
+        with open(metadata_path, 'r') as f:
+            return json.load(f)
+
+    def unload_model(self, ticker: str) -> None:
+        """Unload a model from memory to free resources."""
+        ticker = ticker.upper()
+        if ticker in self._models:
+            del self._models[ticker]
+            del self._scalers[ticker]
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            logger.info(f"Forecast model for {ticker} unloaded")
+
+
+# Singleton instance
+_forecaster_instance: Optional[StockForecaster] = None
+
+
+def get_stock_forecaster() -> StockForecaster:
+    """Get or create the singleton stock forecaster instance."""
+    global _forecaster_instance
+    if _forecaster_instance is None:
+        _forecaster_instance = StockForecaster()
+    return _forecaster_instance

be/forecast_routes.py

@@ -0,0 +1,140 @@
+"""
+Flask routes for stock price forecasting.
+"""
+
+from flask import Blueprint, request, jsonify
+import logging
+
+from forecast_service import get_forecast_service
+
+logger = logging.getLogger(__name__)
+
+forecast_bp = Blueprint('forecast', __name__, url_prefix='/api/forecast')
+
+
+@forecast_bp.route('/predict/<ticker>', methods=['POST'])
+def get_forecast(ticker: str):
+    """
+    Get price forecast for a ticker. Auto-trains if no model exists.
+
+    Request body (optional):
+        {
+            "force_retrain": false,
+            "historical_data": [...]  // Optional: pre-fetched OHLCV data from frontend
+        }
+
+    Response:
+        {
+            "ticker": "AAPL",
+            "forecast": [...],
+            "model_info": {...},
+            "historical": [...],
+            "confidence_bounds": {...}
+        }
+    """
+    try:
+        data = request.get_json() or {}
+        force_retrain = data.get('force_retrain', False)
+        historical_data = data.get('historical_data', None)
+
+        service = get_forecast_service()
+        result = service.get_forecast(ticker.upper(), force_retrain=force_retrain, historical_data=historical_data)
+
+        if "error" in result:
+            return jsonify(result), 400
+
+        return jsonify(result), 200
+
+    except Exception as e:
+        logger.error(f"Error getting forecast for {ticker}: {e}")
+        return jsonify({"error": str(e)}), 500
+
+
+@forecast_bp.route('/train/<ticker>', methods=['POST'])
+def train_model(ticker: str):
+    """
+    Force train/retrain model for a ticker.
+
+    Request body (optional):
+        { "historical_data": [...] }  // Optional: pre-fetched OHLCV data
+
+    Response:
+        {
+            "status": "training_complete",
+            "ticker": "AAPL",
+            "epochs": 50,
+            "final_loss": 0.0023
+        }
+    """
+    try:
+        data = request.get_json() or {}
+        historical_data = data.get('historical_data', None)
+
+        service = get_forecast_service()
+        result = service.train_model(ticker.upper(), historical_data=historical_data)
+
+        if "error" in result:
+            return jsonify(result), 400
+
+        return jsonify(result), 200
+
+    except Exception as e:
+        logger.error(f"Error training model for {ticker}: {e}")
+        return jsonify({"error": str(e)}), 500
+
+
+@forecast_bp.route('/status/<ticker>', methods=['GET'])
+def model_status(ticker: str):
+    """
+    Check model status for a ticker.
+
+    Response:
+        {
+            "ticker": "AAPL",
+            "model_exists": true,
+            "metadata": {...}
+        }
+    """
+    try:
+        service = get_forecast_service()
+        result = service.get_model_status(ticker.upper())
+        return jsonify(result), 200
+
+    except Exception as e:
+        logger.error(f"Error getting model status for {ticker}: {e}")
+        return jsonify({"error": str(e)}), 500
+
+
+@forecast_bp.route('/health', methods=['GET'])
+def forecast_health():
+    """
+    Health check for forecast service.
+
+    Response:
+        {
+            "status": "healthy",
+            "service": "forecast",
+            "model_dir_exists": true
+        }
+    """
+    try:
+        import os
+        from forecast_model import StockForecaster
+
+        model_dir = StockForecaster.MODEL_DIR
+        model_dir_exists = os.path.exists(model_dir)
+
+        return jsonify({
+            "status": "healthy",
+            "service": "forecast",
+            "model_dir": model_dir,
+            "model_dir_exists": model_dir_exists
+        }), 200
+
+    except Exception as e:
+        logger.error(f"Health check failed: {e}")
+        return jsonify({
+            "status": "unhealthy",
+            "service": "forecast",
+            "error": str(e)
+        }), 500

be/forecast_service.py

@@ -0,0 +1,235 @@
+"""
+Service layer for stock price forecasting.
+Orchestrates data fetching, model training, and predictions.
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, Optional
+from polygon_api import PolygonAPI
+from forecast_model import get_stock_forecaster, StockForecaster
+
+logger = logging.getLogger(__name__)
+
+
+class ForecastService:
+    """
+    Service for stock price forecasting.
+    Manages model training, prediction, and caching.
+    """
+
+    TRAINING_DATA_YEARS = 2  # Years of historical data for training
+
+    def __init__(self):
+        self.forecaster: StockForecaster = get_stock_forecaster()
+        self.polygon = PolygonAPI()
+        self._forecast_cache: Dict[str, Dict] = {}  # {ticker: {timestamp, forecast}}
+        self.cache_ttl_minutes = 60
+
+    def get_forecast(self, ticker: str, force_retrain: bool = False, historical_data: list = None) -> Dict:
+        """
+        Get forecast for a ticker. Auto-trains if no model exists.
+
+        Args:
+            ticker: Stock ticker symbol
+            force_retrain: If True, retrain even if model exists
+            historical_data: Optional pre-fetched OHLCV data from frontend cache
+
+        Returns:
+            Dict with forecast data
+        """
+        ticker = ticker.upper()
+
+        # Check if we need to train
+        needs_training = force_retrain or not self.forecaster.has_model(ticker)
+
+        if needs_training:
+            logger.info(f"Training model for {ticker}...")
+            training_result = self.train_model(ticker, historical_data)
+            if training_result.get("status") != "training_complete":
+                return {"error": "Training failed", "details": training_result}
+
+        # Use provided data or fetch if not available
+        if historical_data and len(historical_data) >= 60:
+            recent_data = historical_data
+        else:
+            recent_data = self._fetch_recent_data(ticker)
+            if not recent_data:
+                return {"error": "Failed to fetch recent data for prediction"}
+
+        # Generate forecast
+        try:
+            forecast_result = self.forecaster.predict(ticker, recent_data)
+        except Exception as e:
+            logger.error(f"Prediction failed for {ticker}: {e}")
+            return {"error": f"Prediction failed: {str(e)}"}
+
+        # Get model metadata
+        metadata = self.forecaster.get_model_metadata(ticker)
+
+        # Format response with dates
+        forecast = self._format_forecast(forecast_result, recent_data)
+
+        return {
+            "ticker": ticker,
+            "forecast": forecast,
+            "model_info": metadata,
+            "historical": self._format_historical(recent_data[-60:]),  # Last 60 days for chart
+            "confidence_bounds": {
+                "upper": forecast_result["upper_bound"],
+                "lower": forecast_result["lower_bound"]
+            }
+        }
+
+    def train_model(self, ticker: str, historical_data: list = None) -> Dict:
+        """
+        Train/retrain model for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+            historical_data: Optional pre-fetched OHLCV data from frontend cache
+
+        Returns:
+            Dict with training results
+        """
+        ticker = ticker.upper()
+
+        # Use provided data or fetch if not available
+        if historical_data and len(historical_data) >= 100:
+            training_data = historical_data
+        else:
+            training_data = self._fetch_training_data(ticker)
+            if not training_data:
+                return {"error": "Failed to fetch training data", "ticker": ticker}
+
+        if len(training_data) < 100:
+            return {
+                "error": "Insufficient historical data",
+                "ticker": ticker,
+                "data_points": len(training_data),
+                "required": 100
+            }
+
+        # Train the model
+        try:
+            result = self.forecaster.train(ticker, training_data)
+            return result
+        except Exception as e:
+            logger.error(f"Training failed for {ticker}: {e}")
+            return {"error": f"Training failed: {str(e)}", "ticker": ticker}
+
+    def _fetch_training_data(self, ticker: str) -> Optional[list]:
+        """Fetch historical data for training (2 years)."""
+        to_date = datetime.now()
+        from_date = to_date - timedelta(days=self.TRAINING_DATA_YEARS * 365)
+
+        try:
+            response = self.polygon.get_aggregates(
+                ticker,
+                timespan="day",
+                from_date=from_date.strftime("%Y-%m-%d"),
+                to_date=to_date.strftime("%Y-%m-%d")
+            )
+
+            if "results" not in response or not response["results"]:
+                logger.error(f"Failed to fetch training data for {ticker}: {response}")
+                return None
+
+            return response["results"]
+
+        except Exception as e:
+            logger.error(f"Error fetching training data for {ticker}: {e}")
+            return None
+
+    def _fetch_recent_data(self, ticker: str) -> Optional[list]:
+        """Fetch recent data for prediction (90 days to ensure enough data)."""
+        to_date = datetime.now()
+        from_date = to_date - timedelta(days=90)
+
+        try:
+            response = self.polygon.get_aggregates(
+                ticker,
+                timespan="day",
+                from_date=from_date.strftime("%Y-%m-%d"),
+                to_date=to_date.strftime("%Y-%m-%d")
+            )
+
+            if "results" not in response or not response["results"]:
+                logger.error(f"Failed to fetch recent data for {ticker}: {response}")
+                return None
+
+            return response["results"]
+
+        except Exception as e:
+            logger.error(f"Error fetching recent data for {ticker}: {e}")
+            return None
+
+    def _format_forecast(self, forecast_result: Dict, historical_data: list) -> list:
+        """Format forecast with dates."""
+        predictions = forecast_result["predictions"]
+        upper = forecast_result["upper_bound"]
+        lower = forecast_result["lower_bound"]
+
+        # Start from the last historical date
+        if historical_data:
+            last_timestamp = historical_data[-1].get("t", 0)
+            last_date = datetime.fromtimestamp(last_timestamp / 1000)
+        else:
+            last_date = datetime.now()
+
+        forecast = []
+        current_date = last_date
+
+        for i, pred in enumerate(predictions):
+            # Skip weekends
+            current_date += timedelta(days=1)
+            while current_date.weekday() >= 5:  # 5=Saturday, 6=Sunday
+                current_date += timedelta(days=1)
+
+            forecast.append({
+                "date": current_date.strftime("%Y-%m-%d"),
+                "predicted_close": round(pred, 2),
+                "upper_bound": round(upper[i], 2),
+                "lower_bound": round(lower[i], 2),
+                "day": i + 1
+            })
+
+        return forecast
+
+    def _format_historical(self, data: list) -> list:
+        """Format historical data for chart display."""
+        return [
+            {
+                "date": datetime.fromtimestamp(d["t"] / 1000).strftime("%Y-%m-%d"),
+                "close": d["c"],
+                "open": d["o"],
+                "high": d["h"],
+                "low": d["l"],
+                "volume": d["v"]
+            }
+            for d in data
+        ]
+
+    def get_model_status(self, ticker: str) -> Dict:
+        """Get model status for a ticker."""
+        ticker = ticker.upper()
+        has_model = self.forecaster.has_model(ticker)
+        metadata = self.forecaster.get_model_metadata(ticker) if has_model else None
+
+        return {
+            "ticker": ticker,
+            "model_exists": has_model,
+            "metadata": metadata
+        }
+
+
+# Singleton instance
+_forecast_service: Optional[ForecastService] = None
+
+
+def get_forecast_service() -> ForecastService:
+    """Get or create the singleton forecast service instance."""
+    global _forecast_service
+    if _forecast_service is None:
+        _forecast_service = ForecastService()
+    return _forecast_service

be/llm_client.py

@@ -0,0 +1,267 @@
+import google.generativeai as genai
+from google.genai import types as genai_types
+from google import genai as genai_new
+from datetime import datetime, timedelta
+from config import GEMINI_API_KEY, GEMINI_MODEL, MAX_CONTEXT_LENGTH
+
+
+class GeminiClient:
+    """Handles interactions with Google Gemini API"""
+
+    SYSTEM_PROMPT = """#Context
+    You are an expert stock market analyst with access to the following data for a particular stock ticker:
+    - Real-time stock data (price, volume, market cap)
+    - Historical price charts and trends
+    - News articles with full content
+    - Dividend and split history
+
+    # Task
+    Your task is answer questions related to the ticker based on the information you have been provided.
+
+    When answering questions:
+    - Be concise and data-driven
+    - Cite specific numbers from the data provided
+    - Format numbers with proper units (e.g., $1.5B, 10.5M shares)
+    - Do not include any markdown syntax elements. There is no need to format plain text.
+
+    Always ground your responses in the provided data. If information is not available, say so clearly."""
+
+    def __init__(self, api_key=None, model=None):
+        genai.configure(api_key=api_key or GEMINI_API_KEY)
+        self.model_name = model or GEMINI_MODEL
+        self.model = genai.GenerativeModel(
+            model_name=self.model_name,
+            system_instruction=self.SYSTEM_PROMPT
+        )
+
+    def generate_response(self, prompt, conversation_history=None):
+        """
+        Generate a response from Gemini
+
+        Args:
+            prompt: User prompt with context
+            conversation_history: List of previous messages
+
+        Returns:
+            Generated response text
+        """
+        try:
+            # Convert history to Gemini format and start chat
+            chat = self.model.start_chat(
+                history=self._convert_history(conversation_history)
+            )
+
+            # Generate response
+            response = chat.send_message(prompt)
+            return response.text
+
+        except Exception as e:
+            print(f"Error generating response: {e}")
+            return f"I encountered an error processing your request. Please try again."
+
+    def stream_response(self, prompt, conversation_history=None):
+        """
+        Generate a streaming response from Gemini
+
+        Args:
+            prompt: User prompt with context
+            conversation_history: List of previous messages
+
+        Yields:
+            Response chunks as they arrive
+        """
+        try:
+            # Convert history to Gemini format and start chat
+            chat = self.model.start_chat(
+                history=self._convert_history(conversation_history)
+            )
+
+            # Stream response
+            response = chat.send_message(prompt, stream=True)
+
+            for chunk in response:
+                if chunk.text:
+                    yield chunk.text
+
+        except Exception as e:
+            print(f"Error streaming response: {e}")
+            yield f"I encountered an error processing your request. Please try again."
+
+    def _convert_history(self, history):
+        """
+        Convert OpenAI-style history to Gemini format
+
+        Args:
+            history: List of messages with 'role' and 'content' keys
+
+        Returns:
+            List of Gemini-formatted messages
+        """
+        if not history:
+            return []
+
+        gemini_history = []
+        for msg in history:
+            role = msg.get('role', 'user')
+            content = msg.get('content', '')
+
+            # Gemini uses 'user' and 'model' roles
+            gemini_role = 'user' if role == 'user' else 'model'
+
+            gemini_history.append({
+                'role': gemini_role,
+                'parts': [content]
+            })
+
+        return gemini_history
+
+
+class ConversationManager:
+    """Manages conversation history for chat sessions"""
+
+    def __init__(self):
+        self.conversations = {}
+        self.ttl_hours = 24
+
+    def add_message(self, conversation_id, role, content):
+        """
+        Add a message to conversation history
+
+        Args:
+            conversation_id: Unique conversation identifier
+            role: Message role (user/assistant)
+            content: Message content
+        """
+        if conversation_id not in self.conversations:
+            self.conversations[conversation_id] = {
+                'messages': [],
+                'created_at': datetime.now()
+            }
+
+        self.conversations[conversation_id]['messages'].append({
+            'role': role,
+            'content': content
+        })
+
+        # Clean up old conversations
+        self._cleanup_old_conversations()
+
+    def get_history(self, conversation_id, last_n=5):
+        """
+        Get conversation history
+
+        Args:
+            conversation_id: Unique conversation identifier
+            last_n: Number of recent exchanges to return
+
+        Returns:
+            List of recent messages
+        """
+        if conversation_id not in self.conversations:
+            return []
+
+        messages = self.conversations[conversation_id]['messages']
+
+        # Return last N exchanges (user + assistant pairs)
+        return messages[-(last_n * 2):] if len(messages) > last_n * 2 else messages
+
+    def clear_conversation(self, conversation_id):
+        """Clear a conversation"""
+        if conversation_id in self.conversations:
+            del self.conversations[conversation_id]
+
+    def _cleanup_old_conversations(self):
+        """Remove conversations older than TTL"""
+        cutoff = datetime.now() - timedelta(hours=self.ttl_hours)
+
+        to_delete = [
+            conv_id for conv_id, data in self.conversations.items()
+            if data['created_at'] < cutoff
+        ]
+
+        for conv_id in to_delete:
+            del self.conversations[conv_id]
+
+
+class AgentLLMClient:
+    """Gemini client with function calling support using google-genai SDK."""
+
+    SYSTEM_PROMPT = """You are an expert stock market analyst assistant for MarketLens.
+You have access to tools that provide real-time stock data, financial statements,
+news, sentiment analysis, and price forecasts.
+
+When answering questions:
+- Use your tools to fetch relevant data before answering. Do not guess prices or financial figures.
+- You may call multiple tools if the question requires different types of data.
+- Be concise and data-driven. Cite specific numbers from tool results.
+- Format numbers with proper units (e.g., $1.5B, 10.5M shares).
+- If a tool returns an error, acknowledge the issue and work with whatever data you have.
+- Do not include markdown formatting syntax. Write in plain text.
+- The user is currently viewing the stock ticker: {ticker}. Use this ticker for tool calls unless the user explicitly asks about a different stock.
+- For general questions that do not require data (e.g., "what is a P/E ratio?"), respond directly without calling tools."""
+
+    def __init__(self, api_key=None, model=None):
+        self.client = genai_new.Client(api_key=api_key or GEMINI_API_KEY)
+        self.model_name = model or GEMINI_MODEL
+
+    def build_config(self, tools, ticker):
+        """Build GenerateContentConfig with tools and system prompt."""
+        from agent_tools import TOOL_DECLARATIONS
+
+        function_declarations = [
+            genai_types.FunctionDeclaration(
+                name=t["name"],
+                description=t["description"],
+                parameters_json_schema=t["parameters"],
+            )
+            for t in tools
+        ]
+
+        return genai_types.GenerateContentConfig(
+            system_instruction=self.SYSTEM_PROMPT.format(ticker=ticker),
+            tools=[genai_types.Tool(function_declarations=function_declarations)],
+            automatic_function_calling=genai_types.AutomaticFunctionCallingConfig(disable=True),
+        )
+
+    def generate(self, contents, config):
+        """Send contents to Gemini and return the full response."""
+        return self.client.models.generate_content(
+            model=self.model_name,
+            contents=contents,
+            config=config,
+        )
+
+    @staticmethod
+    def make_user_content(text):
+        """Create a user Content message."""
+        return genai_types.Content(role="user", parts=[genai_types.Part(text=text)])
+
+    @staticmethod
+    def make_tool_response(name, result):
+        """Create a tool response Content message."""
+        return genai_types.Content(
+            role="tool",
+            parts=[genai_types.Part.from_function_response(name=name, response={"result": result})],
+        )
+
+    @staticmethod
+    def history_to_contents(history):
+        """Convert ConversationManager history to genai Contents list."""
+        contents = []
+        for msg in history:
+            role = "user" if msg["role"] == "user" else "model"
+            contents.append(
+                genai_types.Content(role=role, parts=[genai_types.Part(text=msg["content"])])
+            )
+        return contents
+
+    @staticmethod
+    def extract_parts(response):
+        """Extract function_call parts and text from a response."""
+        candidate = response.candidates[0]
+        parts = candidate.content.parts
+
+        function_calls = [p for p in parts if p.function_call]
+        text_parts = [p.text for p in parts if p.text]
+
+        return function_calls, text_parts, candidate.content

be/polygon_api.py

@@ -0,0 +1,90 @@
+import requests
+from config import POLYGON_API_KEY
+
+BASE_URL = "https://api.polygon.io"
+
+class PolygonAPI:
+    def __init__(self):
+        self.api_key = POLYGON_API_KEY
+
+    def get_ticker_details(self, ticker):
+        """Get detailed information about a ticker"""
+        url = f"{BASE_URL}/v3/reference/tickers/{ticker}"
+        params = {"apiKey": self.api_key}
+        response = requests.get(url, params=params)
+        return response.json()
+
+    def get_previous_close(self, ticker):
+        """Get previous day's close data"""
+        url = f"{BASE_URL}/v2/aggs/ticker/{ticker}/prev"
+        params = {"adjusted": "true", "apiKey": self.api_key}
+        response = requests.get(url, params=params)
+        return response.json()
+
+    def get_aggregates(self, ticker, timespan="day", from_date=None, to_date=None):
+        """Get aggregate bars for a ticker over a given date range"""
+        url = f"{BASE_URL}/v2/aggs/ticker/{ticker}/range/1/{timespan}/{from_date}/{to_date}"
+        params = {"adjusted": "true", "sort": "asc", "apiKey": self.api_key}
+        response = requests.get(url, params=params)
+        return response.json()
+
+    def get_ticker_news(self, ticker, limit=10):
+        """Get news articles for a ticker"""
+        url = f"{BASE_URL}/v2/reference/news"
+        params = {
+            "ticker": ticker,
+            "limit": limit,
+            "apiKey": self.api_key
+        }
+        response = requests.get(url, params=params)
+        return response.json()
+
+    def get_financials(self, ticker):
+        """Get financial data for a ticker"""
+        url = f"{BASE_URL}/vX/reference/financials"
+        params = {
+            "ticker": ticker,
+            "limit": 4,
+            "apiKey": self.api_key
+        }
+        response = requests.get(url, params=params)
+        return response.json()
+
+    def get_snapshot(self, ticker):
+        """Get current snapshot of a ticker"""
+        url = f"{BASE_URL}/v2/snapshot/locale/us/markets/stocks/tickers/{ticker}"
+        params = {"apiKey": self.api_key}
+        response = requests.get(url, params=params)
+        return response.json()
+
+    def get_dividends(self, ticker, limit=10):
+        """Get dividend history for a ticker"""
+        url = f"{BASE_URL}/v3/reference/dividends"
+        params = {
+            "ticker": ticker,
+            "limit": limit,
+            "order": "desc",
+            "apiKey": self.api_key
+        }
+        response = requests.get(url, params=params)
+        return response.json()
+
+    def get_splits(self, ticker, limit=10):
+        """Get stock split history for a ticker"""
+        url = f"{BASE_URL}/v3/reference/splits"
+        params = {
+            "ticker": ticker,
+            "limit": limit,
+            "order": "desc",
+            "apiKey": self.api_key
+        }
+        response = requests.get(url, params=params)
+        return response.json()
+
+    def get_market_status(self):
+        """Get current market status"""
+        url = f"{BASE_URL}/v1/marketstatus/now"
+        params = {"apiKey": self.api_key}
+        response = requests.get(url, params=params)
+        return response.json()
+

be/rag_pipeline.py

@@ -0,0 +1,450 @@
+from google import genai as genai_client
+from google.genai import types as genai_types
+import faiss
+import numpy as np
+import json
+import os
+import traceback
+from pathlib import Path
+from config import (
+    GEMINI_API_KEY,
+    FAISS_INDEX_PATH,
+    EMBEDDING_MODEL,
+    RAG_TOP_K
+)
+
+
+class EmbeddingGenerator:
+    """Generates embeddings using Google's Gemini embedding API (FREE)"""
+
+    def __init__(self, api_key=None, model=EMBEDDING_MODEL):
+        self.client = genai_client.Client(api_key=api_key or GEMINI_API_KEY)
+        self.model = f"models/{model}"
+
+    def generate_embedding(self, text):
+        """
+        Generate embedding vector for text
+
+        Args:
+            text: Text to embed
+
+        Returns:
+            List of floats representing the embedding vector
+        """
+        try:
+            if len(text) > 25000:
+                text = text[:25000]
+
+            result = self.client.models.embed_content(
+                model=self.model,
+                contents=text,
+                config=genai_types.EmbedContentConfig(task_type="RETRIEVAL_DOCUMENT"),
+            )
+            return result.embeddings[0].values
+        except Exception as e:
+            print(f"Error generating embedding: {e}")
+            return None
+
+    def generate_query_embedding(self, text):
+        """
+        Generate embedding vector for a query (uses retrieval_query task type)
+
+        Args:
+            text: Query text to embed
+
+        Returns:
+            List of floats representing the embedding vector
+        """
+        try:
+            result = self.client.models.embed_content(
+                model=self.model,
+                contents=text,
+                config=genai_types.EmbedContentConfig(task_type="RETRIEVAL_QUERY"),
+            )
+            return result.embeddings[0].values
+        except Exception as e:
+            print(f"Error generating query embedding: {e}")
+            return None
+
+
+class VectorStore:
+    """Manages FAISS vector database for RAG"""
+
+    def __init__(self, index_path=None):
+        self.index_path = Path(index_path or FAISS_INDEX_PATH)
+        self.index_file = self.index_path / "index.faiss"
+        self.metadata_file = self.index_path / "metadata.json"
+        self.doc_ids_file = self.index_path / "doc_ids.json"
+
+        self.dimension = 3072  # Google gemini-embedding-001
+        self.index = None
+        self.metadata = {}  # {internal_id: metadata_dict}
+        self.doc_id_to_index = {}  # {doc_id: internal_id}
+        self.next_id = 0  # Counter for internal IDs
+
+        self._initialize_index()
+
+    def _initialize_index(self):
+        """Initialize or load FAISS index from disk"""
+        try:
+            # Create directory if doesn't exist
+            self.index_path.mkdir(parents=True, exist_ok=True)
+
+            # Check if index files exist
+            if self.index_file.exists():
+                try:
+                    # Load existing index
+                    self.index = faiss.read_index(str(self.index_file))
+
+                    # Check dimension matches expected
+                    if self.index.d != self.dimension:
+                        print(f"Warning: Index dimension {self.index.d} != expected {self.dimension}, rebuilding index")
+                        raise ValueError("Dimension mismatch")
+
+                    # Load metadata
+                    if self.metadata_file.exists():
+                        with open(self.metadata_file, 'r') as f:
+                            # Convert string keys back to int
+                            loaded = json.load(f)
+                            self.metadata = {int(k): v for k, v in loaded.items()}
+
+                    # Load doc_id mapping
+                    if self.doc_ids_file.exists():
+                        with open(self.doc_ids_file, 'r') as f:
+                            self.doc_id_to_index = json.load(f)
+
+                    # Set next_id to max existing ID + 1
+                    if self.metadata:
+                        self.next_id = max(self.metadata.keys()) + 1
+
+                    print(f"Loaded FAISS index from {self.index_path} with {self.index.ntotal} vectors")
+                except Exception as e:
+                    print(f"Warning: Corrupted index file, creating fresh index: {e}")
+                    # Delete corrupted files
+                    if self.index_file.exists():
+                        self.index_file.unlink()
+                    if self.metadata_file.exists():
+                        self.metadata_file.unlink()
+                    if self.doc_ids_file.exists():
+                        self.doc_ids_file.unlink()
+                    # Create fresh index
+                    self.index = faiss.IndexFlatIP(self.dimension)
+                    self.metadata = {}
+                    self.doc_id_to_index = {}
+                    self.next_id = 0
+            else:
+                # Create new index
+                # Use IndexFlatIP for cosine similarity (requires L2 normalized vectors)
+                self.index = faiss.IndexFlatIP(self.dimension)
+                self.metadata = {}
+                self.doc_id_to_index = {}
+                self.next_id = 0
+                print(f"Created new FAISS index at {self.index_path}")
+
+        except Exception as e:
+            print(f"Error initializing FAISS index: {e}")
+            raise
+
+    def upsert_document(self, doc_id, embedding, metadata, namespace="news"):
+        """
+        Store document embedding with metadata in FAISS
+
+        Args:
+            doc_id: Unique document identifier
+            embedding: Embedding vector (1536 dimensions)
+            metadata: Dictionary of metadata
+            namespace: Namespace for organization (stored in doc_id prefix)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Add namespace to doc_id for organization
+            full_doc_id = f"{namespace}:{doc_id}"
+
+            # Check if document already exists (update case)
+            if full_doc_id in self.doc_id_to_index:
+                # For FAISS, we'll skip true updates and just log
+                # (Alternative: remove old and add new, but requires index rebuild)
+                print(f"Document {full_doc_id} already exists, skipping update")
+                return True
+
+            # Convert to numpy array and normalize for cosine similarity
+            vector = np.array([embedding], dtype=np.float32)
+            faiss.normalize_L2(vector)  # L2 normalize for IndexFlatIP
+
+            # Add to FAISS index
+            self.index.add(vector)
+
+            # Store metadata
+            internal_id = self.next_id
+            self.metadata[internal_id] = metadata.copy()
+            self.metadata[internal_id]['doc_id'] = full_doc_id  # Store doc_id in metadata
+
+            # Update doc_id mapping
+            self.doc_id_to_index[full_doc_id] = internal_id
+
+            # Increment counter
+            self.next_id += 1
+
+            return True
+
+        except Exception as e:
+            print(f"Error upserting document {doc_id}: {e}")
+            traceback.print_exc()
+            return False
+
+    def search(self, query_embedding, ticker=None, doc_type=None, top_k=None, namespace="news"):
+        """
+        Search for similar documents
+
+        Args:
+            query_embedding: Query embedding vector
+            ticker: Filter by ticker symbol
+            doc_type: Filter by document type
+            top_k: Number of results to return
+            namespace: Namespace to search
+
+        Returns:
+            List of matching documents with metadata (Pinecone-compatible format)
+        """
+        try:
+            if self.index.ntotal == 0:
+                return []
+
+            # Normalize query vector for cosine similarity
+            query_vector = np.array([query_embedding], dtype=np.float32)
+            faiss.normalize_L2(query_vector)
+
+            # Calculate search_k (fetch more to allow for filtering)
+            k = top_k or RAG_TOP_K
+            # Fetch 5x more results to account for filtering
+            search_k = min(k * 5, self.index.ntotal)
+
+            # Search FAISS index
+            distances, indices = self.index.search(query_vector, search_k)
+
+            # Build results list with filtering
+            matches = []
+            for dist, idx in zip(distances[0], indices[0]):
+                if idx == -1:  # FAISS returns -1 for invalid indices
+                    continue
+
+                if idx not in self.metadata:
+                    continue
+
+                meta = self.metadata[idx].copy()
+                doc_id = meta.get('doc_id', '')
+
+                # Apply namespace filter
+                if not doc_id.startswith(f"{namespace}:"):
+                    continue
+
+                # Apply ticker filter
+                if ticker and meta.get('ticker') != ticker:
+                    continue
+
+                # Apply doc_type filter
+                if doc_type and meta.get('type') != doc_type:
+                    continue
+
+                # Remove doc_id from metadata (stored separately)
+                meta.pop('doc_id', None)
+
+                # Create Pinecone-compatible match object
+                match = type('Match', (), {
+                    'id': doc_id.replace(f"{namespace}:", ""),  # Remove namespace prefix
+                    'score': float(dist),  # Cosine similarity score
+                    'metadata': meta
+                })()
+
+                matches.append(match)
+
+                # Stop if we have enough matches
+                if len(matches) >= k:
+                    break
+
+            return matches
+
+        except Exception as e:
+            print(f"Error searching FAISS: {e}")
+            return []
+
+    def document_exists(self, doc_id, namespace="news"):
+        """
+        Check if document already exists in index
+
+        Args:
+            doc_id: Document identifier
+            namespace: Namespace
+
+        Returns:
+            Boolean indicating if document exists
+        """
+        try:
+            full_doc_id = f"{namespace}:{doc_id}"
+            return full_doc_id in self.doc_id_to_index
+        except Exception as e:
+            print(f"Error checking document existence: {e}")
+            return False
+
+    def delete_by_ticker(self, ticker, namespace="news"):
+        """
+        Delete all documents for a ticker
+        Note: FAISS doesn't support deletion, so we rebuild the index
+
+        Args:
+            ticker: Ticker symbol
+            namespace: Namespace
+        """
+        try:
+            # Find indices to keep
+            indices_to_keep = []
+            metadata_to_keep = {}
+            doc_ids_to_keep = {}
+            new_id = 0
+
+            for internal_id, meta in self.metadata.items():
+                doc_id = meta.get('doc_id', '')
+
+                # Skip if wrong namespace
+                if not doc_id.startswith(f"{namespace}:"):
+                    indices_to_keep.append(internal_id)
+                    metadata_to_keep[new_id] = meta.copy()
+                    doc_ids_to_keep[doc_id] = new_id
+                    new_id += 1
+                    continue
+
+                # Skip if matching ticker
+                if meta.get('ticker') == ticker:
+                    continue
+
+                # Keep this document
+                indices_to_keep.append(internal_id)
+                metadata_to_keep[new_id] = meta.copy()
+                doc_ids_to_keep[doc_id] = new_id
+                new_id += 1
+
+            if len(indices_to_keep) == len(self.metadata):
+                print(f"No documents found for ticker {ticker}")
+                return
+
+            # Rebuild index with remaining vectors
+            new_index = faiss.IndexFlatIP(self.dimension)
+
+            # Extract and re-add vectors
+            for old_id in indices_to_keep:
+                # Get vector from old index
+                vector = self.index.reconstruct(old_id)
+                # Reshape and add to new index
+                vector = vector.reshape(1, -1)
+                new_index.add(vector)
+
+            # Replace old index and metadata
+            self.index = new_index
+            self.metadata = metadata_to_keep
+            self.doc_id_to_index = doc_ids_to_keep
+            self.next_id = new_id
+
+            deleted_count = len(self.metadata) - len(metadata_to_keep)
+            print(f"Deleted {deleted_count} documents for {ticker}")
+
+        except Exception as e:
+            print(f"Error deleting documents for {ticker}: {e}")
+
+    def save(self):
+        """
+        Manually save index and metadata to disk
+        Call this after batch operations or on graceful shutdown
+        """
+        try:
+            # Ensure directory exists
+            self.index_path.mkdir(parents=True, exist_ok=True)
+
+            # Write to temporary files first for atomic saves
+            temp_index = str(self.index_file) + ".tmp"
+            temp_metadata = str(self.metadata_file) + ".tmp"
+            temp_docids = str(self.doc_ids_file) + ".tmp"
+
+            # Save FAISS index
+            faiss.write_index(self.index, temp_index)
+
+            # Save metadata (convert int keys to strings for JSON)
+            with open(temp_metadata, 'w') as f:
+                json.dump({str(k): v for k, v in self.metadata.items()}, f, indent=2)
+
+            # Save doc_id mapping
+            with open(temp_docids, 'w') as f:
+                json.dump(self.doc_id_to_index, f, indent=2)
+
+            # Atomic rename (overwrite old files)
+            os.replace(temp_index, str(self.index_file))
+            os.replace(temp_metadata, str(self.metadata_file))
+            os.replace(temp_docids, str(self.doc_ids_file))
+
+            print(f"Saved FAISS index with {self.index.ntotal} vectors to {self.index_path}")
+            return True
+
+        except Exception as e:
+            print(f"Error saving FAISS index: {e}")
+            # Clean up temp files
+            for temp_file in [temp_index, temp_metadata, temp_docids]:
+                if os.path.exists(temp_file):
+                    os.remove(temp_file)
+            return False
+
+    def get_stats(self):
+        """Get index statistics"""
+        return {
+            "total_vectors": self.index.ntotal,
+            "dimension": self.dimension,
+            "total_metadata": len(self.metadata),
+            "index_type": "IndexFlatIP",
+            "metric": "cosine"
+        }
+
+
+class ContextRetriever:
+    """High-level interface for retrieving relevant context"""
+
+    def __init__(self, vector_store=None):
+        self.embedding_gen = EmbeddingGenerator()
+        self.vector_store = vector_store or VectorStore()
+
+    def retrieve_context(self, query, ticker, doc_type=None, top_k=None):
+        """
+        Retrieve relevant documents for a query
+
+        Args:
+            query: User query text
+            ticker: Ticker symbol to filter by
+            doc_type: Optional document type filter
+            top_k: Number of results to return
+
+        Returns:
+            List of relevant documents with metadata
+        """
+        # Generate query embedding (use query-specific embedding for better retrieval)
+        query_embedding = self.embedding_gen.generate_query_embedding(query)
+
+        if not query_embedding:
+            return []
+
+        # Search vector store
+        matches = self.vector_store.search(
+            query_embedding=query_embedding,
+            ticker=ticker,
+            doc_type=doc_type,
+            top_k=top_k
+        )
+
+        # Format results
+        contexts = []
+        for match in matches:
+            contexts.append({
+                'score': match.score,
+                'metadata': match.metadata,
+                'id': match.id
+            })
+
+        return contexts

be/requirements.txt

@@ -0,0 +1,19 @@
+Flask==3.0.0
+gunicorn==21.2.0
+Flask-CORS==4.0.0
+requests==2.31.0
+python-dotenv==1.0.0
+
+# Chatbot (using Google Gemini - FREE)
+google-genai>=1.0.0
+faiss-cpu==1.7.4
+numpy==1.24.3
+beautifulsoup4==4.12.3
+lxml==5.1.0
+tenacity==8.2.3
+
+# Sentiment Analysis
+transformers==4.36.0
+torch==2.1.0
+praw==7.7.1
+cloudscraper==1.2.71

be/scraper.py

@@ -0,0 +1,134 @@
+import requests
+from bs4 import BeautifulSoup
+import re
+import json
+
+
+class ArticleScraper:
+    """Web scraper for extracting full article content from news URLs"""
+
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        })
+
+    def scrape_article(self, url, timeout=10):
+        """
+        Scrape full article content from a news URL
+
+        Args:
+            url: Article URL to scrape
+            timeout: Request timeout in seconds
+
+        Returns:
+            Cleaned article text or None if scraping fails
+        """
+        try:
+            response = self.session.get(url, timeout=timeout)
+            response.raise_for_status()
+
+            soup = BeautifulSoup(response.content, 'lxml')
+
+            # Try multiple extraction methods in order of reliability
+            article_content = (
+                self._extract_by_schema(soup) or
+                self._extract_by_selector(soup, 'article') or
+                self._extract_by_selector(soup, '.article-body') or
+                self._extract_by_selector(soup, '.article-content') or
+                self._extract_by_selector(soup, '#article-content') or
+                self._extract_by_selector(soup, '.story-body') or
+                self._extract_by_selector(soup, '.entry-content') or
+                self._extract_paragraphs(soup)
+            )
+
+            if article_content:
+                return self._clean_text(article_content)
+            else:
+                print(f"Could not extract content from {url}")
+                return None
+
+        except requests.exceptions.Timeout:
+            print(f"Timeout scraping {url}")
+            return None
+        except requests.exceptions.RequestException as e:
+            print(f"Request error scraping {url}: {e}")
+            return None
+        except Exception as e:
+            print(f"Unexpected error scraping {url}: {e}")
+            return None
+
+    def _extract_by_selector(self, soup, selector):
+        """Extract text from a CSS selector"""
+        element = soup.select_one(selector)
+        if element:
+            paragraphs = element.find_all('p')
+            if paragraphs:
+                return ' '.join(p.get_text() for p in paragraphs)
+        return None
+
+    def _extract_by_schema(self, soup):
+        """Extract article body from JSON-LD schema.org metadata"""
+        script_tags = soup.find_all('script', type='application/ld+json')
+
+        for script_tag in script_tags:
+            try:
+                data = json.loads(script_tag.string)
+
+                # Handle both single objects and arrays
+                if isinstance(data, list):
+                    for item in data:
+                        if self._extract_article_body(item):
+                            return self._extract_article_body(item)
+                else:
+                    if self._extract_article_body(data):
+                        return self._extract_article_body(data)
+            except (json.JSONDecodeError, AttributeError):
+                continue
+
+        return None
+
+    def _extract_article_body(self, data):
+        """Extract articleBody from JSON-LD data"""
+        if isinstance(data, dict):
+            if data.get('@type') in ['Article', 'NewsArticle', 'BlogPosting']:
+                return data.get('articleBody')
+        return None
+
+    def _extract_paragraphs(self, soup):
+        """Fallback: Extract all paragraph tags from body"""
+        # Remove script, style, nav, footer, and header elements
+        for element in soup(['script', 'style', 'nav', 'footer', 'header', 'aside']):
+            element.decompose()
+
+        # Find all paragraphs
+        paragraphs = soup.find_all('p')
+
+        if len(paragraphs) >= 3:  # Only use if we found a reasonable number of paragraphs
+            text = ' '.join(p.get_text() for p in paragraphs)
+            # Only return if we got substantial content
+            if len(text) > 200:
+                return text
+
+        return None
+
+    def _clean_text(self, text):
+        """Clean and normalize extracted text"""
+        if not text:
+            return None
+
+        # Remove extra whitespace
+        text = re.sub(r'\s+', ' ', text)
+
+        # Remove common cruft
+        text = re.sub(r'(Advertisement|ADVERTISEMENT)', '', text)
+        text = re.sub(r'(Read more:.*?\.)', '', text)
+
+        # Strip leading/trailing whitespace
+        text = text.strip()
+
+        # Only return if we have substantial content
+        if len(text) > 100:
+            return text
+
+        return None

be/sentiment_analyzer.py

@@ -0,0 +1,212 @@
+"""
+FinBERT-based sentiment analyzer for financial text.
+Uses ProsusAI/finbert model for classifying text as positive, negative, or neutral.
+"""
+
+import warnings
+# Suppress huggingface_hub deprecation warning about resume_download
+warnings.filterwarnings("ignore", message=".*resume_download.*", category=FutureWarning)
+
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from typing import List, Dict, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SentimentAnalyzer:
+    """
+    Financial sentiment analyzer using FinBERT.
+
+    The model is lazy-loaded on first use to avoid slow startup times.
+    Supports both single text and batch analysis for efficiency.
+    """
+
+    MODEL_NAME = "ProsusAI/finbert"
+    LABELS = ["negative", "neutral", "positive"]
+
+    def __init__(self):
+        self._model: Optional[AutoModelForSequenceClassification] = None
+        self._tokenizer: Optional[AutoTokenizer] = None
+        self._device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    def _load_model(self) -> None:
+        """Lazy load the FinBERT model on first use."""
+        if self._model is not None:
+            return
+
+        logger.info(f"Loading FinBERT model ({self.MODEL_NAME})...")
+        try:
+            self._tokenizer = AutoTokenizer.from_pretrained(self.MODEL_NAME)
+            self._model = AutoModelForSequenceClassification.from_pretrained(self.MODEL_NAME)
+            self._model.to(self._device)
+            self._model.eval()
+            logger.info(f"FinBERT model loaded successfully on {self._device}")
+        except Exception as e:
+            logger.error(f"Failed to load FinBERT model: {e}")
+            raise
+
+    def analyze(self, text: str) -> Dict:
+        """
+        Analyze sentiment of a single text.
+
+        Args:
+            text: The financial text to analyze
+
+        Returns:
+            dict with keys:
+                - label: "positive", "neutral", or "negative"
+                - score: confidence score (0-1)
+                - scores: dict of all label scores
+        """
+        if not text or not text.strip():
+            return {
+                "label": "neutral",
+                "score": 1.0,
+                "scores": {"negative": 0.0, "neutral": 1.0, "positive": 0.0}
+            }
+
+        self._load_model()
+
+        try:
+            inputs = self._tokenizer(
+                text,
+                return_tensors="pt",
+                truncation=True,
+                max_length=512,
+                padding=True
+            )
+            inputs = {k: v.to(self._device) for k, v in inputs.items()}
+
+            with torch.no_grad():
+                outputs = self._model(**inputs)
+                probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+
+            probs = probs.cpu()
+            scores = {label: float(prob) for label, prob in zip(self.LABELS, probs[0])}
+            predicted_idx = probs.argmax().item()
+
+            return {
+                "label": self.LABELS[predicted_idx],
+                "score": float(probs[0][predicted_idx]),
+                "scores": scores
+            }
+
+        except Exception as e:
+            logger.error(f"Sentiment analysis failed: {e}")
+            return {
+                "label": "neutral",
+                "score": 0.5,
+                "scores": {"negative": 0.0, "neutral": 1.0, "positive": 0.0}
+            }
+
+    def analyze_batch(self, texts: List[str], batch_size: int = 16) -> List[Dict]:
+        """
+        Analyze sentiment of multiple texts efficiently.
+
+        Args:
+            texts: List of texts to analyze
+            batch_size: Number of texts to process at once
+
+        Returns:
+            List of sentiment dicts (same format as analyze())
+        """
+        if not texts:
+            return []
+
+        self._load_model()
+
+        results = []
+
+        for i in range(0, len(texts), batch_size):
+            batch_texts = texts[i:i + batch_size]
+
+            # Filter out empty texts, keeping track of indices
+            valid_indices = []
+            valid_texts = []
+            for j, text in enumerate(batch_texts):
+                if text and text.strip():
+                    valid_indices.append(j)
+                    valid_texts.append(text)
+
+            # Initialize results for this batch with neutral defaults
+            batch_results = [{
+                "label": "neutral",
+                "score": 1.0,
+                "scores": {"negative": 0.0, "neutral": 1.0, "positive": 0.0}
+            } for _ in batch_texts]
+
+            if not valid_texts:
+                results.extend(batch_results)
+                continue
+
+            try:
+                inputs = self._tokenizer(
+                    valid_texts,
+                    return_tensors="pt",
+                    truncation=True,
+                    max_length=512,
+                    padding=True
+                )
+                inputs = {k: v.to(self._device) for k, v in inputs.items()}
+
+                with torch.no_grad():
+                    outputs = self._model(**inputs)
+                    probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+
+                probs = probs.cpu()
+
+                for idx, (valid_idx, prob) in enumerate(zip(valid_indices, probs)):
+                    scores = {label: float(p) for label, p in zip(self.LABELS, prob)}
+                    predicted_idx = prob.argmax().item()
+                    batch_results[valid_idx] = {
+                        "label": self.LABELS[predicted_idx],
+                        "score": float(prob[predicted_idx]),
+                        "scores": scores
+                    }
+
+            except Exception as e:
+                logger.error(f"Batch sentiment analysis failed: {e}")
+
+            results.extend(batch_results)
+
+        return results
+
+    def convert_to_aggregate_score(self, sentiment: Dict) -> float:
+        """
+        Convert sentiment dict to a single score from -1 (bearish) to +1 (bullish).
+
+        Args:
+            sentiment: Sentiment dict from analyze()
+
+        Returns:
+            float: Score from -1 to +1
+        """
+        scores = sentiment.get("scores", {})
+        positive = scores.get("positive", 0)
+        negative = scores.get("negative", 0)
+        return positive - negative
+
+    def unload_model(self) -> None:
+        """Unload the model to free memory."""
+        if self._model is not None:
+            del self._model
+            del self._tokenizer
+            self._model = None
+            self._tokenizer = None
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            logger.info("FinBERT model unloaded")
+
+
+# Singleton instance for reuse
+_analyzer_instance: Optional[SentimentAnalyzer] = None
+
+
+def get_sentiment_analyzer() -> SentimentAnalyzer:
+    """Get or create the singleton sentiment analyzer instance."""
+    global _analyzer_instance
+    if _analyzer_instance is None:
+        _analyzer_instance = SentimentAnalyzer()
+    return _analyzer_instance

be/sentiment_routes.py

@@ -0,0 +1,211 @@
+"""
+Flask routes for sentiment analysis API.
+"""
+
+from flask import Blueprint, request, jsonify
+import logging
+import traceback
+
+from sentiment_service import get_sentiment_service
+
+logger = logging.getLogger(__name__)
+
+sentiment_bp = Blueprint('sentiment', __name__, url_prefix='/api/sentiment')
+
+
+@sentiment_bp.route('/analyze', methods=['POST'])
+def analyze_sentiment():
+    """
+    Analyze social media sentiment for a ticker.
+
+    Request body:
+        { "ticker": "AAPL" }
+
+    Response:
+        {
+            "aggregate": {
+                "score": 0.65,
+                "label": "bullish",
+                "confidence": 0.78,
+                "post_count": 47,
+                "sources": { "stocktwits": 30, "reddit": 12, "twitter": 5 }
+            },
+            "posts": [...],
+            "scraped": 50,
+            "embedded": 47,
+            "failed": 3
+        }
+    """
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "Request body required"}), 400
+
+        ticker = data.get('ticker', '').strip().upper()
+        if not ticker:
+            return jsonify({"error": "Ticker symbol required"}), 400
+
+        force_refresh = data.get('force_refresh', False)
+
+        logger.info(f"Sentiment analysis request for {ticker} (force_refresh={force_refresh})")
+
+        service = get_sentiment_service()
+        result = service.analyze_ticker(ticker, force_refresh=force_refresh)
+
+        return jsonify(result)
+
+    except Exception as e:
+        logger.error(f"Error in sentiment analysis: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+@sentiment_bp.route('/summary/<ticker>', methods=['GET'])
+def get_sentiment_summary(ticker: str):
+    """
+    Get cached sentiment summary for a ticker.
+
+    Does not re-scrape - uses existing data from FAISS.
+
+    Response:
+        {
+            "ticker": "AAPL",
+            "aggregate_score": 0.65,
+            "label": "bullish",
+            "confidence": 0.78,
+            "post_count": 47,
+            "last_updated": "2026-01-18T12:00:00Z"
+        }
+    """
+    try:
+        ticker = ticker.strip().upper()
+        if not ticker:
+            return jsonify({"error": "Ticker symbol required"}), 400
+
+        service = get_sentiment_service()
+        summary = service.get_summary(ticker)
+
+        return jsonify(summary)
+
+    except Exception as e:
+        logger.error(f"Error getting sentiment summary: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+@sentiment_bp.route('/posts/<ticker>', methods=['GET'])
+def get_sentiment_posts(ticker: str):
+    """
+    Get sentiment posts for a ticker with filtering.
+
+    Query params:
+        platform: Filter by platform (stocktwits, reddit, twitter)
+        sentiment: Filter by sentiment (positive, negative, neutral)
+        limit: Max posts to return (default 50)
+        offset: Pagination offset (default 0)
+
+    Response:
+        {
+            "posts": [...],
+            "total": 47,
+            "filters": { "platform": "all", "sentiment": "all" }
+        }
+    """
+    try:
+        ticker = ticker.strip().upper()
+        if not ticker:
+            return jsonify({"error": "Ticker symbol required"}), 400
+
+        # Parse query parameters
+        platform = request.args.get('platform', 'all').lower()
+        sentiment = request.args.get('sentiment', 'all').lower()
+        limit = min(int(request.args.get('limit', 50)), 100)
+        offset = int(request.args.get('offset', 0))
+
+        service = get_sentiment_service()
+
+        # Retrieve posts from FAISS
+        contexts = service.retrieve_sentiment_context(
+            query=f"{ticker} stock social media",
+            ticker=ticker,
+            top_k=limit + offset + 50  # Fetch extra for filtering
+        )
+
+        # Apply filters
+        filtered_posts = []
+        for ctx in contexts:
+            meta = ctx['metadata']
+
+            # Platform filter
+            if platform != 'all' and meta.get('platform') != platform:
+                continue
+
+            # Sentiment filter
+            if sentiment != 'all' and meta.get('sentiment_label') != sentiment:
+                continue
+
+            filtered_posts.append({
+                "id": ctx['id'],
+                "platform": meta.get('platform', 'unknown'),
+                "content": meta.get('full_content', meta.get('content', ''))[:500],
+                "author": meta.get('author', ''),
+                "timestamp": meta.get('timestamp', ''),
+                "sentiment": {
+                    "label": meta.get('sentiment_label', 'neutral'),
+                    "score": meta.get('sentiment_score', 0.5)
+                },
+                "engagement": {
+                    "likes": meta.get('likes', 0),
+                    "comments": meta.get('comments', 0),
+                    "score": meta.get('engagement_score', 0)
+                },
+                "url": meta.get('url', '')
+            })
+
+        # Apply pagination
+        total = len(filtered_posts)
+        paginated = filtered_posts[offset:offset + limit]
+
+        return jsonify({
+            "posts": paginated,
+            "total": total,
+            "limit": limit,
+            "offset": offset,
+            "filters": {
+                "platform": platform,
+                "sentiment": sentiment
+            }
+        })
+
+    except Exception as e:
+        logger.error(f"Error getting sentiment posts: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+@sentiment_bp.route('/health', methods=['GET'])
+def sentiment_health():
+    """Health check for sentiment service."""
+    try:
+        service = get_sentiment_service()
+
+        # Check if sentiment analyzer can be accessed
+        analyzer = service.sentiment_analyzer
+
+        return jsonify({
+            "status": "healthy",
+            "model": "ProsusAI/finbert",
+            "model_loaded": analyzer._model is not None,
+            "platforms": {
+                "stocktwits": True,
+                "reddit": bool(service.aggregator.scrapers["reddit"].enabled),
+                "twitter": bool(service.aggregator.scrapers["twitter"].enabled)
+            }
+        })
+
+    except Exception as e:
+        logger.error(f"Sentiment health check failed: {e}")
+        return jsonify({
+            "status": "unhealthy",
+            "error": str(e)
+        }), 500

be/sentiment_service.py

@@ -0,0 +1,470 @@
+"""
+Sentiment analysis service that orchestrates:
+1. Social media scraping
+2. FinBERT sentiment analysis
+3. FAISS vector storage for RAG
+4. Aggregate sentiment calculation
+"""
+
+import json
+import math
+import os
+import logging
+from datetime import datetime, timezone
+from typing import Dict, List, Optional
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from sentiment_analyzer import get_sentiment_analyzer
+from social_scrapers import SocialMediaAggregator
+from rag_pipeline import EmbeddingGenerator, VectorStore
+from config import (
+    REDDIT_CLIENT_ID,
+    REDDIT_CLIENT_SECRET,
+    REDDIT_USER_AGENT,
+    TWITTER_BEARER_TOKEN
+)
+
+logger = logging.getLogger(__name__)
+
+
+class SentimentService:
+    """
+    Main service for social media sentiment analysis.
+
+    Coordinates scraping, sentiment analysis, embedding generation,
+    and vector storage for RAG integration.
+    """
+
+    NAMESPACE = "sentiment"
+    MAX_POSTS_PER_PLATFORM = 30
+    MAX_WORKERS = 5
+    CACHE_TTL_MINUTES = 15
+    CACHE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "sentiment_cache")
+
+    # Bias correction: asymmetric thresholds to counteract bullish bias in data sources
+    # Social media (WSB, StockTwits) skews positive; FinBERT also has slight positive bias
+    BULLISH_THRESHOLD = 0.3    # Higher bar for bullish (was 0.2)
+    BEARISH_THRESHOLD = -0.15  # Lower bar for bearish (was -0.2)
+
+    # Minimum confidence to include a post in aggregate calculation
+    MIN_CONFIDENCE_THRESHOLD = 0.6
+
+    def __init__(self, vector_store: Optional[VectorStore] = None):
+        """
+        Initialize the sentiment service.
+
+        Args:
+            vector_store: Shared VectorStore instance (for consistency with chat service)
+        """
+        self.vector_store = vector_store or VectorStore()
+        self.embedding_gen = EmbeddingGenerator()
+        self.sentiment_analyzer = get_sentiment_analyzer()
+
+        self.aggregator = SocialMediaAggregator(
+            reddit_client_id=REDDIT_CLIENT_ID,
+            reddit_client_secret=REDDIT_CLIENT_SECRET,
+            reddit_user_agent=REDDIT_USER_AGENT,
+            twitter_bearer_token=TWITTER_BEARER_TOKEN
+        )
+
+    def _get_cached_result(self, ticker: str) -> Optional[Dict]:
+        """Return cached sentiment result if fresh, None if stale or missing."""
+        cache_path = os.path.join(self.CACHE_DIR, f"{ticker}.json")
+        try:
+            if not os.path.exists(cache_path):
+                return None
+            with open(cache_path, "r") as f:
+                cached = json.load(f)
+            cached_at = datetime.fromisoformat(cached["cached_at"])
+            age_minutes = (datetime.now(timezone.utc) - cached_at).total_seconds() / 60
+            if age_minutes > self.CACHE_TTL_MINUTES:
+                logger.info(f"Sentiment cache expired for {ticker} ({age_minutes:.1f} min old)")
+                return None
+            logger.info(f"Sentiment cache hit for {ticker} ({age_minutes:.1f} min old)")
+            return cached["result"]
+        except Exception as e:
+            logger.warning(f"Error reading sentiment cache for {ticker}: {e}")
+            return None
+
+    def _save_result_to_cache(self, ticker: str, result: Dict) -> None:
+        """Persist sentiment result to disk cache."""
+        try:
+            os.makedirs(self.CACHE_DIR, exist_ok=True)
+            cache_path = os.path.join(self.CACHE_DIR, f"{ticker}.json")
+            payload = {
+                "cached_at": datetime.now(timezone.utc).isoformat(),
+                "result": result
+            }
+            with open(cache_path, "w") as f:
+                json.dump(payload, f)
+            logger.info(f"Sentiment result cached for {ticker}")
+        except Exception as e:
+            logger.warning(f"Error saving sentiment cache for {ticker}: {e}")
+
+    def analyze_ticker(self, ticker: str, force_refresh: bool = False) -> Dict:
+        """
+        Full sentiment analysis pipeline for a ticker.
+
+        1. Scrapes social media posts
+        2. Analyzes sentiment with FinBERT
+        3. Embeds and stores in FAISS
+        4. Calculates aggregate sentiment
+
+        Args:
+            ticker: Stock ticker symbol (e.g., "AAPL")
+
+        Returns:
+            dict with aggregate sentiment, posts, and stats
+        """
+        ticker = ticker.upper()
+
+        # Check disk cache first (skip if force refresh)
+        if not force_refresh:
+            cached = self._get_cached_result(ticker)
+            if cached is not None:
+                return cached
+
+        logger.info(f"Starting sentiment analysis for {ticker}")
+
+        # Step 1: Scrape posts from all platforms
+        platform_posts = self.aggregator.scrape_all(ticker, limit_per_platform=self.MAX_POSTS_PER_PLATFORM)
+
+        all_posts = []
+        for posts in platform_posts.values():
+            all_posts.extend(posts)
+
+        if not all_posts:
+            logger.warning(f"No social media posts found for {ticker}")
+            return {
+                "aggregate": {
+                    "score": 0,
+                    "label": "neutral",
+                    "confidence": 0,
+                    "post_count": 0,
+                    "sources": {"stocktwits": 0, "reddit": 0, "twitter": 0}
+                },
+                "posts": [],
+                "scraped": 0,
+                "embedded": 0,
+                "failed": 0
+            }
+
+        # Step 2: Analyze sentiment for all posts
+        texts = [post["content"] for post in all_posts]
+        sentiments = self.sentiment_analyzer.analyze_batch(texts)
+
+        # Attach sentiment to posts
+        for post, sentiment in zip(all_posts, sentiments):
+            post["sentiment"] = sentiment
+            post["sentiment_label"] = sentiment["label"]
+            post["sentiment_score"] = sentiment["score"]
+
+        # Step 3: Embed and store posts in FAISS
+        embedded_count = 0
+        failed_count = 0
+
+        def embed_and_store(post):
+            """Embed a single post and store in vector DB."""
+            try:
+                doc_id = post["id"]
+
+                # Skip if already exists
+                if self.vector_store.document_exists(doc_id, namespace=self.NAMESPACE):
+                    return "skipped"
+
+                # Generate embedding
+                embedding = self.embedding_gen.generate_embedding(post["content"])
+                if not embedding:
+                    return "failed"
+
+                # Prepare metadata for storage
+                metadata = {
+                    "ticker": ticker,
+                    "type": "social_post",
+                    "platform": post.get("platform", "unknown"),
+                    "content": post["content"][:500],  # Truncate for storage
+                    "content_preview": post["content"][:200],
+                    "full_content": post["content"],
+                    "author": post.get("author", ""),
+                    "timestamp": post.get("timestamp", ""),
+                    "likes": post.get("likes", 0),
+                    "comments": post.get("comments", 0),
+                    "engagement_score": post.get("engagement_score", 0),
+                    "sentiment_label": post["sentiment_label"],
+                    "sentiment_score": post["sentiment_score"],
+                    "url": post.get("url", "")
+                }
+
+                # Store in FAISS
+                success = self.vector_store.upsert_document(
+                    doc_id=doc_id,
+                    embedding=embedding,
+                    metadata=metadata,
+                    namespace=self.NAMESPACE
+                )
+
+                return "embedded" if success else "failed"
+
+            except Exception as e:
+                logger.error(f"Error embedding post {post.get('id', 'unknown')}: {e}")
+                return "failed"
+
+        # Process posts in parallel
+        with ThreadPoolExecutor(max_workers=self.MAX_WORKERS) as executor:
+            futures = {executor.submit(embed_and_store, post): post for post in all_posts}
+
+            for future in as_completed(futures):
+                result = future.result()
+                if result == "embedded":
+                    embedded_count += 1
+                elif result == "failed":
+                    failed_count += 1
+
+        # Save FAISS index after batch operation
+        self.vector_store.save()
+
+        # Step 4: Calculate aggregate sentiment
+        aggregate = self._calculate_aggregate_sentiment(all_posts)
+        aggregate["sources"] = self.aggregator.get_source_counts(all_posts)
+
+        # Sort posts by engagement and recency for display
+        sorted_posts = sorted(
+            all_posts,
+            key=lambda x: (x.get("engagement_score", 0), x.get("timestamp", "")),
+            reverse=True
+        )
+
+        # Format posts for response
+        formatted_posts = [self._format_post_for_response(p) for p in sorted_posts[:50]]
+
+        logger.info(f"Sentiment analysis complete for {ticker}: {aggregate['label']} ({aggregate['score']:.2f})")
+
+        result = {
+            "aggregate": aggregate,
+            "posts": formatted_posts,
+            "scraped": len(all_posts),
+            "embedded": embedded_count,
+            "failed": failed_count
+        }
+
+        # Save to disk cache
+        self._save_result_to_cache(ticker, result)
+
+        return result
+
+    def get_summary(self, ticker: str) -> Dict:
+        """
+        Get a quick sentiment summary without re-scraping.
+
+        Uses existing data from FAISS if available.
+
+        Args:
+            ticker: Stock ticker symbol
+
+        Returns:
+            Summary dict with aggregate score and metadata
+        """
+        ticker = ticker.upper()
+
+        # Search for existing sentiment data
+        query_embedding = self.embedding_gen.generate_query_embedding(f"{ticker} stock sentiment")
+        if not query_embedding:
+            return {"ticker": ticker, "error": "Failed to generate query embedding"}
+
+        matches = self.vector_store.search(
+            query_embedding=query_embedding,
+            ticker=ticker,
+            namespace=self.NAMESPACE,
+            top_k=100
+        )
+
+        if not matches:
+            return {
+                "ticker": ticker,
+                "aggregate_score": 0,
+                "label": "neutral",
+                "post_count": 0,
+                "last_updated": None
+            }
+
+        # Reconstruct posts from matches
+        posts = []
+        latest_timestamp = None
+
+        for match in matches:
+            meta = match.metadata
+            posts.append({
+                "sentiment_label": meta.get("sentiment_label", "neutral"),
+                "sentiment_score": meta.get("sentiment_score", 0.5),
+                "engagement_score": meta.get("engagement_score", 0),
+                "timestamp": meta.get("timestamp", "")
+            })
+
+            ts = meta.get("timestamp")
+            if ts and (not latest_timestamp or ts > latest_timestamp):
+                latest_timestamp = ts
+
+        aggregate = self._calculate_aggregate_sentiment(posts)
+
+        return {
+            "ticker": ticker,
+            "aggregate_score": aggregate["score"],
+            "label": aggregate["label"],
+            "confidence": aggregate["confidence"],
+            "post_count": len(posts),
+            "last_updated": latest_timestamp
+        }
+
+    def retrieve_sentiment_context(self, query: str, ticker: str, top_k: int = 5) -> List[Dict]:
+        """
+        Retrieve relevant sentiment posts for RAG.
+
+        Args:
+            query: User query
+            ticker: Stock ticker
+            top_k: Number of results
+
+        Returns:
+            List of relevant posts with sentiment data
+        """
+        query_embedding = self.embedding_gen.generate_query_embedding(query)
+        if not query_embedding:
+            return []
+
+        matches = self.vector_store.search(
+            query_embedding=query_embedding,
+            ticker=ticker,
+            namespace=self.NAMESPACE,
+            top_k=top_k
+        )
+
+        contexts = []
+        for match in matches:
+            contexts.append({
+                "score": match.score,
+                "metadata": match.metadata,
+                "id": match.id
+            })
+
+        return contexts
+
+    def _calculate_aggregate_sentiment(self, posts: List[Dict]) -> Dict:
+        """
+        Calculate weighted aggregate sentiment with bias correction.
+
+        Weighting factors:
+        - Recency: Posts from last 24h weighted 2x
+        - Engagement: log(1 + engagement_score)
+        - Confidence: FinBERT confidence score (filtered by MIN_CONFIDENCE_THRESHOLD)
+
+        Bias corrections:
+        - Asymmetric thresholds for bullish/bearish classification
+        - Confidence filtering to exclude low-confidence predictions
+        - Neutral posts contribute slightly negative (-0.05) to counteract positive bias
+        """
+        if not posts:
+            return {"score": 0, "label": "neutral", "confidence": 0, "post_count": 0}
+
+        weighted_sum = 0
+        total_weight = 0
+        now = datetime.now(timezone.utc)
+
+        # Track sentiment distribution for logging
+        distribution = {"positive": 0, "neutral": 0, "negative": 0}
+        filtered_count = 0
+
+        for post in posts:
+            label = post.get("sentiment_label", "neutral")
+            confidence = post.get("sentiment_score", 0.5)
+
+            # Track raw distribution before filtering
+            distribution[label] = distribution.get(label, 0) + 1
+
+            # Filter out low-confidence predictions
+            if confidence < self.MIN_CONFIDENCE_THRESHOLD:
+                filtered_count += 1
+                continue
+
+            # Convert sentiment label to numeric score
+            # Neutral posts get slight negative bias (-0.05) to counteract data source bias
+            base_score = {"negative": -1, "neutral": -0.05, "positive": 1}.get(label, 0)
+
+            # Recency weight
+            recency_weight = 1.0
+            timestamp = post.get("timestamp")
+            if timestamp:
+                try:
+                    if isinstance(timestamp, str):
+                        post_time = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+                    else:
+                        post_time = timestamp
+
+                    hours_old = (now - post_time).total_seconds() / 3600
+                    recency_weight = 2.0 if hours_old < 24 else (1.5 if hours_old < 72 else 1.0)
+                except:
+                    pass
+
+            # Engagement weight
+            engagement = post.get("engagement_score", 0)
+            engagement_weight = math.log(1 + engagement + 1)
+
+            # Combined weight
+            weight = confidence * recency_weight * engagement_weight
+            weighted_sum += base_score * weight
+            total_weight += weight
+
+        # Log sentiment distribution for debugging
+        logger.info(
+            f"Sentiment distribution: {distribution} | "
+            f"Filtered (low confidence): {filtered_count} | "
+            f"Included: {len(posts) - filtered_count}"
+        )
+
+        avg_score = weighted_sum / total_weight if total_weight > 0 else 0
+
+        # Determine label using asymmetric thresholds to counteract bullish bias
+        if avg_score < self.BEARISH_THRESHOLD:
+            label = "bearish"
+        elif avg_score > self.BULLISH_THRESHOLD:
+            label = "bullish"
+        else:
+            label = "neutral"
+
+        included_count = len(posts) - filtered_count
+        return {
+            "score": round(avg_score, 3),
+            "label": label,
+            "confidence": round(min(1.0, total_weight / max(1, included_count) / 2), 3),
+            "post_count": len(posts),
+            "included_count": included_count,
+            "distribution": distribution
+        }
+
+    def _format_post_for_response(self, post: Dict) -> Dict:
+        """Format a post for API response."""
+        return {
+            "id": post.get("id", ""),
+            "platform": post.get("platform", "unknown"),
+            "content": post.get("content", "")[:500],
+            "author": post.get("author", ""),
+            "timestamp": post.get("timestamp", ""),
+            "sentiment": post.get("sentiment", {}),
+            "engagement": {
+                "likes": post.get("likes", 0),
+                "comments": post.get("comments", 0),
+                "score": post.get("engagement_score", 0)
+            },
+            "url": post.get("url", "")
+        }
+
+
+# Singleton instance
+_sentiment_service: Optional[SentimentService] = None
+
+
+def get_sentiment_service(vector_store: Optional[VectorStore] = None) -> SentimentService:
+    """Get or create the singleton sentiment service instance."""
+    global _sentiment_service
+    if _sentiment_service is None:
+        _sentiment_service = SentimentService(vector_store=vector_store)
+    return _sentiment_service

be/social_scrapers.py

@@ -0,0 +1,525 @@
+"""
+Social media scrapers for stock sentiment data.
+Supports StockTwits, Reddit, and Twitter (optional).
+"""
+
+import requests
+import cloudscraper
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional
+from datetime import datetime, timezone
+import logging
+import hashlib
+
+logger = logging.getLogger(__name__)
+
+
+class BaseScraper(ABC):
+    """Base class for social media scrapers."""
+
+    @abstractmethod
+    def scrape(self, ticker: str, limit: int = 50) -> List[Dict]:
+        """
+        Fetch posts for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol (e.g., "AAPL")
+            limit: Maximum number of posts to return
+
+        Returns:
+            List of standardized post dicts
+        """
+        pass
+
+    def generate_post_id(self, platform: str, unique_id: str) -> str:
+        """Generate a unique post ID."""
+        return f"{platform}_{unique_id}"
+
+    def calculate_engagement_score(self, likes: int, comments: int, retweets: int = 0) -> int:
+        """Calculate total engagement score."""
+        return likes + comments + retweets
+
+
+class StockTwitsScraper(BaseScraper):
+    """
+    StockTwits API scraper.
+
+    - FREE, no authentication required for basic access
+    - Rate limit: ~200 requests/hour
+    - Endpoint: https://api.stocktwits.com/api/2/streams/symbol/{symbol}.json
+    - Uses cloudscraper to bypass Cloudflare protection
+    """
+
+    BASE_URL = "https://api.stocktwits.com/api/2"
+    TIMEOUT = 10
+
+    def __init__(self):
+        """Initialize with cloudscraper session to handle Cloudflare."""
+        self.scraper = cloudscraper.create_scraper()
+
+    def scrape(self, ticker: str, limit: int = 50) -> List[Dict]:
+        """Fetch posts from StockTwits for a ticker."""
+        url = f"{self.BASE_URL}/streams/symbol/{ticker.upper()}.json"
+
+        try:
+            response = self.scraper.get(url, timeout=self.TIMEOUT)
+            response.raise_for_status()
+            data = response.json()
+
+            if data.get("response", {}).get("status") != 200:
+                logger.warning(f"StockTwits API error for {ticker}: {data}")
+                return []
+
+            posts = []
+            messages = data.get("messages", [])[:limit]
+
+            for msg in messages:
+                try:
+                    post = self._standardize_post(msg, ticker)
+                    if post:
+                        posts.append(post)
+                except Exception as e:
+                    logger.debug(f"Failed to parse StockTwits message: {e}")
+                    continue
+
+            logger.info(f"Scraped {len(posts)} posts from StockTwits for {ticker}")
+            return posts
+
+        except requests.exceptions.Timeout:
+            logger.warning(f"StockTwits request timed out for {ticker}")
+            return []
+        except requests.exceptions.RequestException as e:
+            logger.error(f"StockTwits scraping error for {ticker}: {e}")
+            return []
+        except Exception as e:
+            logger.error(f"Unexpected StockTwits error for {ticker}: {e}")
+            return []
+
+    def _standardize_post(self, raw: Dict, ticker: str) -> Optional[Dict]:
+        """Convert StockTwits message to standard format."""
+        msg_id = raw.get("id")
+        if not msg_id:
+            return None
+
+        body = raw.get("body", "").strip()
+        if not body:
+            return None
+
+        user = raw.get("user", {})
+        created_at = raw.get("created_at", "")
+
+        # Parse timestamp
+        timestamp = None
+        if created_at:
+            try:
+                timestamp = datetime.fromisoformat(created_at.replace("Z", "+00:00")).isoformat()
+            except:
+                timestamp = created_at
+
+        # StockTwits has built-in sentiment
+        st_sentiment = raw.get("entities", {}).get("sentiment", {})
+        st_sentiment_label = st_sentiment.get("basic") if st_sentiment else None
+
+        likes_data = raw.get("likes", {})
+        likes_count = likes_data.get("total", 0) if isinstance(likes_data, dict) else 0
+
+        return {
+            "id": self.generate_post_id("stocktwits", str(msg_id)),
+            "platform": "stocktwits",
+            "ticker": ticker.upper(),
+            "content": body,
+            "author": user.get("username", "unknown"),
+            "author_followers": user.get("followers", 0),
+            "timestamp": timestamp,
+            "likes": likes_count,
+            "comments": 0,  # Not available in basic API
+            "retweets": 0,
+            "engagement_score": self.calculate_engagement_score(likes_count, 0),
+            "url": f"https://stocktwits.com/{user.get('username', '')}/message/{msg_id}",
+            "stocktwits_sentiment": st_sentiment_label  # "Bullish" or "Bearish" if available
+        }
+
+
+class RedditScraper(BaseScraper):
+    """
+    Direct Reddit scraper using public JSON endpoints.
+
+    - No API credentials required
+    - Uses cloudscraper to bypass Cloudflare
+    - Subreddits: wallstreetbets, stocks, investing, options
+    """
+
+    SUBREDDITS = ["wallstreetbets", "stocks", "investing", "options"]
+    BASE_URL = "https://www.reddit.com"
+    TIMEOUT = 10
+
+    def __init__(self, client_id: str = "", client_secret: str = "", user_agent: str = "StockAssistant/1.0"):
+        # Credentials no longer needed, but keep params for backwards compatibility
+        self.scraper = cloudscraper.create_scraper()
+        self.user_agent = user_agent
+
+    def scrape(self, ticker: str, limit: int = 50) -> List[Dict]:
+        """Fetch posts from Reddit for a ticker using public JSON endpoints."""
+        posts = []
+        seen_ids = set()
+        per_subreddit = max(1, limit // len(self.SUBREDDITS))
+
+        for subreddit_name in self.SUBREDDITS:
+            if len(posts) >= limit:
+                break
+
+            # Search with $ prefix (common in finance subs) and plain ticker
+            for query in [f"${ticker.upper()}", ticker.upper()]:
+                if len(posts) >= limit:
+                    break
+
+                try:
+                    url = f"{self.BASE_URL}/r/{subreddit_name}/search.json"
+                    params = {
+                        "q": query,
+                        "limit": per_subreddit,
+                        "t": "week",
+                        "sort": "relevance",
+                        "restrict_sr": "true"
+                    }
+
+                    response = self.scraper.get(
+                        url,
+                        params=params,
+                        timeout=self.TIMEOUT,
+                        headers={"User-Agent": self.user_agent}
+                    )
+                    response.raise_for_status()
+                    data = response.json()
+
+                    children = data.get("data", {}).get("children", [])
+
+                    for child in children:
+                        if len(posts) >= limit:
+                            break
+
+                        post_data = child.get("data", {})
+                        post_id = post_data.get("id")
+
+                        if post_id and post_id not in seen_ids:
+                            post = self._standardize_post(post_data, ticker, subreddit_name)
+                            if post:
+                                posts.append(post)
+                                seen_ids.add(post_id)
+
+                except requests.exceptions.Timeout:
+                    logger.warning(f"Reddit request timed out for r/{subreddit_name}")
+                    continue
+                except requests.exceptions.RequestException as e:
+                    logger.warning(f"Reddit scraping error for r/{subreddit_name}: {e}")
+                    continue
+                except Exception as e:
+                    logger.debug(f"Reddit search failed for {query} in r/{subreddit_name}: {e}")
+                    continue
+
+        logger.info(f"Scraped {len(posts)} posts from Reddit for {ticker}")
+        return posts[:limit]
+
+    def _standardize_post(self, post_data: Dict, ticker: str, subreddit: str) -> Optional[Dict]:
+        """Convert Reddit JSON post to standard format."""
+        try:
+            post_id = post_data.get("id")
+            if not post_id:
+                return None
+
+            title = post_data.get("title", "").strip()
+            selftext = post_data.get("selftext", "").strip()
+
+            # Combine title and selftext
+            if selftext and selftext != "[removed]" and selftext != "[deleted]":
+                content = f"{title}\n\n{selftext}"
+            else:
+                content = title
+
+            if not content:
+                return None
+
+            # Truncate very long posts
+            if len(content) > 2000:
+                content = content[:2000] + "..."
+
+            # Parse timestamp
+            created_utc = post_data.get("created_utc", 0)
+            timestamp = datetime.fromtimestamp(created_utc, tz=timezone.utc).isoformat()
+
+            author = post_data.get("author", "[deleted]")
+            if author == "[deleted]":
+                author = "[deleted]"
+
+            score = post_data.get("score", 0)
+            num_comments = post_data.get("num_comments", 0)
+            permalink = post_data.get("permalink", "")
+
+            return {
+                "id": self.generate_post_id("reddit", post_id),
+                "platform": "reddit",
+                "ticker": ticker.upper(),
+                "content": content,
+                "author": author,
+                "author_followers": 0,
+                "timestamp": timestamp,
+                "likes": score,
+                "comments": num_comments,
+                "retweets": 0,
+                "engagement_score": self.calculate_engagement_score(score, num_comments),
+                "url": f"https://reddit.com{permalink}",
+                "subreddit": subreddit
+            }
+
+        except Exception as e:
+            logger.debug(f"Failed to parse Reddit post: {e}")
+            return None
+
+
+class TwitterScraper(BaseScraper):
+    """
+    Twitter/X API v2 scraper.
+
+    NOTE: Twitter API v2 requires paid access ($100+/month for Basic tier).
+    This scraper is disabled by default unless TWITTER_BEARER_TOKEN is set.
+
+    - Rate limit (Basic tier): 10,000 tweets/month
+    - Endpoint: https://api.twitter.com/2/tweets/search/recent
+    - Search window: Last 7 days only (recent search)
+    """
+
+    BASE_URL = "https://api.twitter.com/2"
+    TIMEOUT = 15
+
+    def __init__(self, bearer_token: str = ""):
+        self.bearer_token = bearer_token
+        self.enabled = bool(bearer_token)
+
+    def scrape(self, ticker: str, limit: int = 50) -> List[Dict]:
+        """
+        Fetch tweets for a ticker using Twitter API v2 recent search.
+
+        Args:
+            ticker: Stock ticker symbol (e.g., "AAPL")
+            limit: Maximum number of tweets to return (max 100 per request)
+
+        Returns:
+            List of standardized post dicts
+        """
+        if not self.enabled:
+            logger.debug("Twitter scraper disabled - no bearer token (requires $100+/month)")
+            return []
+
+        # Build search query for stock ticker
+        # Search for cashtag ($AAPL) and common stock-related terms
+        query = f"${ticker.upper()} (stock OR shares OR trading OR buy OR sell OR price) -is:retweet lang:en"
+
+        # Limit to max 100 per request (Twitter API limit)
+        max_results = min(limit, 100)
+
+        url = f"{self.BASE_URL}/tweets/search/recent"
+        headers = {
+            "Authorization": f"Bearer {self.bearer_token}",
+            "Content-Type": "application/json"
+        }
+        params = {
+            "query": query,
+            "max_results": max_results,
+            "tweet.fields": "created_at,public_metrics,author_id,conversation_id",
+            "user.fields": "username,name,public_metrics",
+            "expansions": "author_id"
+        }
+
+        try:
+            response = requests.get(url, headers=headers, params=params, timeout=self.TIMEOUT)
+
+            # Handle rate limiting
+            if response.status_code == 429:
+                logger.warning("Twitter API rate limit reached")
+                return []
+
+            # Handle authentication errors
+            if response.status_code == 401:
+                logger.error("Twitter API authentication failed - check bearer token")
+                return []
+
+            if response.status_code == 403:
+                logger.error("Twitter API access forbidden - may need higher tier access")
+                return []
+
+            response.raise_for_status()
+            data = response.json()
+
+            # Check for errors in response
+            if "errors" in data and not data.get("data"):
+                for error in data.get("errors", []):
+                    logger.warning(f"Twitter API error: {error.get('message', 'Unknown error')}")
+                return []
+
+            tweets = data.get("data", [])
+            if not tweets:
+                logger.info(f"No tweets found for {ticker}")
+                return []
+
+            # Build user lookup map from expansions
+            users = {}
+            includes = data.get("includes", {})
+            for user in includes.get("users", []):
+                users[user["id"]] = user
+
+            # Parse tweets
+            posts = []
+            for tweet in tweets:
+                try:
+                    post = self._standardize_post(tweet, ticker, users)
+                    if post:
+                        posts.append(post)
+                except Exception as e:
+                    logger.debug(f"Failed to parse tweet: {e}")
+                    continue
+
+            logger.info(f"Scraped {len(posts)} tweets from Twitter for {ticker}")
+            return posts
+
+        except requests.exceptions.Timeout:
+            logger.warning(f"Twitter request timed out for {ticker}")
+            return []
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Twitter API error for {ticker}: {e}")
+            return []
+        except Exception as e:
+            logger.error(f"Unexpected Twitter error for {ticker}: {e}")
+            return []
+
+    def _standardize_post(self, tweet: Dict, ticker: str, users: Dict) -> Optional[Dict]:
+        """
+        Convert Twitter API v2 tweet to standard format.
+
+        Args:
+            tweet: Raw tweet data from API
+            ticker: Stock ticker symbol
+            users: User lookup map from expansions
+
+        Returns:
+            Standardized post dict or None
+        """
+        tweet_id = tweet.get("id")
+        if not tweet_id:
+            return None
+
+        text = tweet.get("text", "").strip()
+        if not text:
+            return None
+
+        # Get author info from users map
+        author_id = tweet.get("author_id", "")
+        author_info = users.get(author_id, {})
+        username = author_info.get("username", "unknown")
+        author_metrics = author_info.get("public_metrics", {})
+        followers = author_metrics.get("followers_count", 0)
+
+        # Parse timestamp
+        created_at = tweet.get("created_at", "")
+        timestamp = None
+        if created_at:
+            try:
+                # Twitter API v2 uses ISO 8601 format
+                timestamp = datetime.fromisoformat(created_at.replace("Z", "+00:00")).isoformat()
+            except Exception:
+                timestamp = created_at
+
+        # Get engagement metrics
+        metrics = tweet.get("public_metrics", {})
+        likes = metrics.get("like_count", 0)
+        retweets = metrics.get("retweet_count", 0)
+        replies = metrics.get("reply_count", 0)
+        quotes = metrics.get("quote_count", 0)
+
+        return {
+            "id": self.generate_post_id("twitter", tweet_id),
+            "platform": "twitter",
+            "ticker": ticker.upper(),
+            "content": text,
+            "author": username,
+            "author_followers": followers,
+            "timestamp": timestamp,
+            "likes": likes,
+            "comments": replies,
+            "retweets": retweets + quotes,
+            "engagement_score": self.calculate_engagement_score(likes, replies, retweets + quotes),
+            "url": f"https://twitter.com/{username}/status/{tweet_id}"
+        }
+
+
+class SocialMediaAggregator:
+    """
+    Aggregates posts from all social media platforms.
+    """
+
+    def __init__(
+        self,
+        reddit_client_id: str = "",
+        reddit_client_secret: str = "",
+        reddit_user_agent: str = "StockAssistant/1.0",
+        twitter_bearer_token: str = ""
+    ):
+        self.scrapers = {
+            "stocktwits": StockTwitsScraper(),
+            "reddit": RedditScraper(reddit_client_id, reddit_client_secret, reddit_user_agent),
+            "twitter": TwitterScraper(twitter_bearer_token)
+        }
+
+    def scrape_all(self, ticker: str, limit_per_platform: int = 30) -> Dict[str, List[Dict]]:
+        """
+        Scrape posts from all available platforms.
+
+        Args:
+            ticker: Stock ticker symbol
+            limit_per_platform: Max posts per platform
+
+        Returns:
+            Dict mapping platform name to list of posts
+        """
+        results = {}
+
+        for platform, scraper in self.scrapers.items():
+            try:
+                posts = scraper.scrape(ticker, limit=limit_per_platform)
+                results[platform] = posts
+            except Exception as e:
+                logger.error(f"Failed to scrape {platform}: {e}")
+                results[platform] = []
+
+        return results
+
+    def scrape_all_combined(self, ticker: str, total_limit: int = 50) -> List[Dict]:
+        """
+        Scrape from all platforms and return combined list sorted by recency.
+
+        Args:
+            ticker: Stock ticker symbol
+            total_limit: Total max posts across all platforms
+
+        Returns:
+            List of posts sorted by timestamp (newest first)
+        """
+        per_platform = max(1, total_limit // 3)  # Distribute across 3 platforms
+        results = self.scrape_all(ticker, limit_per_platform=per_platform)
+
+        all_posts = []
+        for posts in results.values():
+            all_posts.extend(posts)
+
+        # Sort by timestamp (newest first)
+        all_posts.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+
+        return all_posts[:total_limit]
+
+    def get_source_counts(self, posts: List[Dict]) -> Dict[str, int]:
+        """Count posts by platform."""
+        counts = {"stocktwits": 0, "reddit": 0, "twitter": 0}
+        for post in posts:
+            platform = post.get("platform", "")
+            if platform in counts:
+                counts[platform] += 1
+        return counts

fe/app.js

@@ -0,0 +1,2479 @@
+const API_BASE = 'http://localhost:5000/api';
+let allTickers = [];
+let currentTicker = '';
+let chartInstance = null;
+let highlightedIndex = -1;
+let dropdownItems = [];
+
+// Cache TTL configuration (in minutes)
+const CACHE_TTL = {
+    STATIC: null,           // Cache until page refresh
+    DAILY: 1440,            // 24 hours (for EOD data)
+    MODERATE: 30,           // 30 minutes
+    SHORT: 15               // 15 minutes
+};
+
+// Cache manager
+const cache = {
+    data: {},
+
+    set(key, value, ttlMinutes = null) {
+        this.data[key] = {
+            value: value,
+            timestamp: Date.now(),
+            ttl: ttlMinutes ? ttlMinutes * 60 * 1000 : null
+        };
+    },
+
+    get(key) {
+        const item = this.data[key];
+        if (!item) return null;
+
+        // Check if expired
+        if (item.ttl && (Date.now() - item.timestamp > item.ttl)) {
+            delete this.data[key];
+            return null;
+        }
+
+        return item.value;
+    },
+
+    has(key) {
+        return this.get(key) !== null;
+    },
+
+    clear() {
+        this.data = {};
+    },
+
+    getStats() {
+        return {
+            entries: Object.keys(this.data).length,
+            keys: Object.keys(this.data)
+        };
+    }
+};
+
+// Expose cache to global scope for debugging
+window.stockCache = cache;
+
+// Recent/Popular Ticker Functions
+function getRecentTickers() {
+    try {
+        const recent = localStorage.getItem('recentTickers');
+        if (recent) {
+            return JSON.parse(recent);
+        }
+    } catch (error) {
+        console.error('Error reading recent tickers:', error);
+    }
+    return [];
+}
+
+function saveRecentTicker(ticker, title) {
+    try {
+        let recent = getRecentTickers();
+
+        // Remove if already exists
+        recent = recent.filter(item => item.ticker !== ticker);
+
+        // Add to front
+        recent.unshift({ ticker, title });
+
+        // Keep only 5 most recent
+        recent = recent.slice(0, 5);
+
+        localStorage.setItem('recentTickers', JSON.stringify(recent));
+    } catch (error) {
+        console.error('Error saving recent ticker:', error);
+    }
+}
+
+function getPopularTickers() {
+    const popularSymbols = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'META', 'NVDA', 'AMD'];
+    return allTickers.filter(ticker => popularSymbols.includes(ticker.ticker));
+}
+
+// Dropdown control functions
+function showDropdown() {
+    document.getElementById('dropdownList').classList.remove('hidden');
+}
+
+function hideDropdown() {
+    document.getElementById('dropdownList').classList.add('hidden');
+    highlightedIndex = -1;
+}
+
+function populateDropdown(tickers, searchTerm = '') {
+    const dropdown = document.getElementById('dropdownList');
+    dropdown.innerHTML = '';
+    dropdownItems = [];
+
+    if (searchTerm === '') {
+        // Show recent and popular tickers
+        const recent = getRecentTickers();
+        const popular = getPopularTickers();
+
+        if (recent.length > 0) {
+            const recentHeader = document.createElement('div');
+            recentHeader.className = 'dropdown-section-header';
+            recentHeader.textContent = 'Recent';
+            dropdown.appendChild(recentHeader);
+
+            recent.forEach(item => {
+                const div = createDropdownItem(item.ticker, item.title);
+                dropdown.appendChild(div);
+                dropdownItems.push({ element: div, ticker: item.ticker, title: item.title });
+            });
+        }
+
+        if (popular.length > 0) {
+            const popularHeader = document.createElement('div');
+            popularHeader.className = 'dropdown-section-header';
+            popularHeader.textContent = 'Popular';
+            dropdown.appendChild(popularHeader);
+
+            popular.forEach(item => {
+                const div = createDropdownItem(item.ticker, item.title);
+                dropdown.appendChild(div);
+                dropdownItems.push({ element: div, ticker: item.ticker, title: item.title });
+            });
+        }
+    } else {
+        // Show filtered results
+        const limited = tickers.slice(0, 50);
+
+        if (limited.length === 0) {
+            const noResults = document.createElement('div');
+            noResults.className = 'dropdown-no-results';
+            noResults.textContent = 'No results found';
+            dropdown.appendChild(noResults);
+        } else {
+            limited.forEach(item => {
+                const div = createDropdownItem(item.ticker, item.title);
+                dropdown.appendChild(div);
+                dropdownItems.push({ element: div, ticker: item.ticker, title: item.title });
+            });
+        }
+    }
+}
+
+function createDropdownItem(ticker, title) {
+    const div = document.createElement('div');
+    div.className = 'dropdown-item';
+    div.textContent = `${ticker} - ${title}`;
+    div.dataset.ticker = ticker;
+    div.dataset.title = title;
+
+    // Use mousedown instead of click to fire before blur
+    div.addEventListener('mousedown', (e) => {
+        e.preventDefault();
+        selectTicker(ticker, title);
+    });
+
+    return div;
+}
+
+function selectTicker(ticker, title) {
+    const input = document.getElementById('tickerSearch');
+    input.value = `${ticker} - ${title}`;
+    currentTicker = ticker;
+    hideDropdown();
+    saveRecentTicker(ticker, title);
+    loadStockData(ticker);
+    updateChatContext();
+}
+
+function highlightItem(index) {
+    // Remove all highlights
+    dropdownItems.forEach(item => item.element.classList.remove('highlighted'));
+
+    if (index >= 0 && index < dropdownItems.length) {
+        dropdownItems[index].element.classList.add('highlighted');
+        dropdownItems[index].element.scrollIntoView({ block: 'nearest' });
+    }
+}
+
+// Load tickers on page load
+document.addEventListener('DOMContentLoaded', async () => {
+    initTheme();
+    await loadTickers();
+    await loadMarketStatus();
+    setupEventListeners();
+});
+
+// Theme toggle functionality
+function initTheme() {
+    const savedTheme = localStorage.getItem('theme');
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+
+    if (savedTheme) {
+        document.documentElement.setAttribute('data-theme', savedTheme);
+    } else if (prefersDark) {
+        document.documentElement.setAttribute('data-theme', 'dark');
+    }
+
+    const themeToggle = document.getElementById('themeToggle');
+    if (themeToggle) {
+        themeToggle.addEventListener('click', toggleTheme);
+    }
+}
+
+function toggleTheme() {
+    const currentTheme = document.documentElement.getAttribute('data-theme');
+    const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
+
+    document.documentElement.setAttribute('data-theme', newTheme);
+    localStorage.setItem('theme', newTheme);
+
+    // Redraw chart with new theme colors
+    if (chartState.data) {
+        drawChart(1);
+    }
+}
+
+async function loadTickers() {
+    try {
+        const response = await fetch('../company_tickers.json');
+        const data = await response.json();
+
+        allTickers = Object.values(data).map(item => ({
+            ticker: item.ticker,
+            title: item.title,
+            cik: item.cik_str
+        }));
+    } catch (error) {
+        console.error('Error loading tickers:', error);
+    }
+}
+
+function setupEventListeners() {
+    const tickerSearch = document.getElementById('tickerSearch');
+    const dropdownContainer = document.querySelector('.dropdown-container');
+
+    // Input focus - show dropdown with recent/popular or current results
+    tickerSearch.addEventListener('focus', (e) => {
+        const searchTerm = e.target.value.trim();
+        if (searchTerm === '') {
+            populateDropdown([], '');
+        } else {
+            // Select all text for easy replacement
+            e.target.select();
+            const filtered = allTickers.filter(item =>
+                item.ticker.toLowerCase().includes(searchTerm.toLowerCase()) ||
+                item.title.toLowerCase().includes(searchTerm.toLowerCase())
+            );
+            populateDropdown(filtered, searchTerm);
+        }
+        showDropdown();
+    });
+
+    // Input blur - hide dropdown with delay
+    tickerSearch.addEventListener('blur', () => {
+        setTimeout(() => {
+            hideDropdown();
+        }, 200);
+    });
+
+    // Input keydown - handle keyboard navigation
+    tickerSearch.addEventListener('keydown', (e) => {
+        const dropdown = document.getElementById('dropdownList');
+        const isOpen = !dropdown.classList.contains('hidden');
+
+        if (!isOpen && e.key !== 'Escape') return;
+
+        switch(e.key) {
+            case 'Escape':
+                if (e.target.value) {
+                    e.target.value = '';
+                    populateDropdown([], '');
+                    showDropdown();
+                } else {
+                    hideDropdown();
+                }
+                break;
+
+            case 'ArrowDown':
+                e.preventDefault();
+                highlightedIndex++;
+                if (highlightedIndex >= dropdownItems.length) {
+                    highlightedIndex = 0;
+                }
+                highlightItem(highlightedIndex);
+                break;
+
+            case 'ArrowUp':
+                e.preventDefault();
+                highlightedIndex--;
+                if (highlightedIndex < 0) {
+                    highlightedIndex = dropdownItems.length - 1;
+                }
+                highlightItem(highlightedIndex);
+                break;
+
+            case 'Enter':
+                e.preventDefault();
+                if (highlightedIndex >= 0 && highlightedIndex < dropdownItems.length) {
+                    const item = dropdownItems[highlightedIndex];
+                    selectTicker(item.ticker, item.title);
+                }
+                break;
+        }
+    });
+
+    // Input input - filter and show results
+    tickerSearch.addEventListener('input', (e) => {
+        const searchTerm = e.target.value.trim();
+        highlightedIndex = -1;
+
+        if (searchTerm === '') {
+            populateDropdown([], '');
+        } else {
+            const filtered = allTickers.filter(item =>
+                item.ticker.toLowerCase().includes(searchTerm.toLowerCase()) ||
+                item.title.toLowerCase().includes(searchTerm.toLowerCase())
+            );
+            populateDropdown(filtered, searchTerm);
+        }
+        showDropdown();
+    });
+
+    // Click outside to close dropdown
+    document.addEventListener('click', (e) => {
+        if (!dropdownContainer.contains(e.target)) {
+            hideDropdown();
+        }
+    });
+
+    // Tab switching
+    const tabButtons = document.querySelectorAll('.tab-button');
+    tabButtons.forEach(button => {
+        button.addEventListener('click', () => {
+            const tabName = button.dataset.tab;
+            switchTab(tabName);
+        });
+    });
+
+    // Chart range buttons
+    const rangeButtons = document.querySelectorAll('.chart-range-btn');
+    rangeButtons.forEach(button => {
+        button.addEventListener('click', () => {
+            const range = button.dataset.range;
+            loadChartData(currentTicker, range);
+            rangeButtons.forEach(btn => btn.classList.remove('active'));
+            button.classList.add('active');
+        });
+    });
+
+    // Chart view toggle buttons (line/candle)
+    const viewButtons = document.querySelectorAll('.chart-view-btn');
+    viewButtons.forEach(button => {
+        button.addEventListener('click', () => {
+            viewButtons.forEach(btn => btn.classList.remove('active'));
+            button.classList.add('active');
+            chartState.viewMode = button.dataset.view;
+            if (chartState.data) {
+                drawChart(1);
+            }
+        });
+    });
+
+    // Setup chat listeners
+    setupChatListeners();
+}
+
+function switchTab(tabName) {
+    const tabButtons = document.querySelectorAll('.tab-button');
+    const tabPanes = document.querySelectorAll('.tab-pane');
+
+    tabButtons.forEach(btn => btn.classList.remove('active'));
+    tabPanes.forEach(pane => pane.classList.remove('active'));
+
+    document.querySelector(`[data-tab="${tabName}"]`).classList.add('active');
+    document.getElementById(tabName).classList.add('active');
+
+    if (tabName === 'overview' && currentTicker) {
+        loadChartData(currentTicker, document.querySelector('.chart-range-btn.active').dataset.range || '1M');
+    } else if (tabName === 'financials' && currentTicker) {
+        loadFinancials(currentTicker);
+    } else if (tabName === 'news' && currentTicker) {
+        loadNews(currentTicker);
+    } else if (tabName === 'dividends' && currentTicker) {
+        loadDividends(currentTicker);
+    } else if (tabName === 'splits' && currentTicker) {
+        loadSplits(currentTicker);
+    } else if (tabName === 'sentiment' && currentTicker) {
+        loadSentiment(currentTicker);
+    } else if (tabName === 'forecast' && currentTicker) {
+        loadForecast(currentTicker);
+    }
+}
+
+function clearStockDisplay() {
+    document.getElementById('stockTitle').textContent = '';
+    document.getElementById('stockPrice').textContent = '';
+    document.getElementById('stockPrice').className = 'stock-price';
+    document.getElementById('companyDesc').textContent = '';
+    document.getElementById('marketCap').textContent = '--';
+    document.getElementById('openPrice').textContent = '--';
+    document.getElementById('highPrice').textContent = '--';
+    document.getElementById('lowPrice').textContent = '--';
+    document.getElementById('volume').textContent = '--';
+    document.getElementById('peRatio').textContent = '--';
+}
+
+async function loadStockData(ticker) {
+    currentTicker = ticker;
+    document.getElementById('stockData').classList.remove('hidden');
+    clearStockDisplay();
+
+    try {
+        const activeTab = document.querySelector('.tab-button.active').dataset.tab;
+        const loadPromises = [
+            loadTickerDetails(ticker),
+            loadPreviousClose(ticker)
+        ];
+        if (activeTab === 'overview') {
+            loadPromises.push(loadChartData(ticker, '1M'));
+        }
+        await Promise.all(loadPromises);
+
+        if (activeTab === 'financials') {
+            await loadFinancials(ticker);
+        } else if (activeTab === 'news') {
+            await loadNews(ticker);
+        } else if (activeTab === 'sentiment') {
+            loadSentiment(ticker);
+        } else if (activeTab === 'forecast') {
+            loadForecast(ticker);
+        } else if (activeTab === 'dividends') {
+            loadDividends(ticker);
+        } else if (activeTab === 'splits') {
+            loadSplits(ticker);
+        }
+
+        // Preload news and trigger article scraping for RAG in background
+        preloadNewsForRAG(ticker);
+    } catch (error) {
+        console.error('Error loading stock data:', error);
+        alert('Error loading stock data. Please check your API key and try again.');
+    }
+}
+
+async function loadTickerDetails(ticker) {
+    const cacheKey = `details_${ticker}`;
+
+    // Check cache first
+    if (cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        renderTickerDetails(data);
+        return;
+    }
+
+    try {
+        const response = await fetch(`${API_BASE}/ticker/${ticker}/details`);
+        const data = await response.json();
+
+        if (data.results) {
+            cache.set(cacheKey, data, CACHE_TTL.STATIC);
+            renderTickerDetails(data);
+        }
+    } catch (error) {
+        console.error('Error loading ticker details:', error);
+    }
+}
+
+function renderTickerDetails(data) {
+    if (data.results) {
+        const results = data.results;
+        document.getElementById('stockTitle').textContent =
+            `${results.ticker} - ${results.name}`;
+        document.getElementById('companyDesc').textContent =
+            results.description || 'No description available';
+        document.getElementById('marketCap').textContent =
+            results.market_cap ? formatLargeNumber(results.market_cap) : '--';
+    }
+}
+
+async function loadSnapshot(ticker) {
+    try {
+        const response = await fetch(`${API_BASE}/ticker/${ticker}/snapshot`);
+        const data = await response.json();
+
+        if (data.ticker) {
+            const ticker_data = data.ticker;
+            const day = ticker_data.day || {};
+
+            document.getElementById('openPrice').textContent =
+                day.o ? `$${day.o.toFixed(2)}` : '--';
+            document.getElementById('highPrice').textContent =
+                day.h ? `$${day.h.toFixed(2)}` : '--';
+            document.getElementById('lowPrice').textContent =
+                day.l ? `$${day.l.toFixed(2)}` : '--';
+            document.getElementById('volume').textContent =
+                day.v ? formatLargeNumber(day.v) : '--';
+        }
+    } catch (error) {
+        console.error('Error loading snapshot:', error);
+    }
+}
+
+async function loadPreviousClose(ticker) {
+    const cacheKey = `prev_close_${ticker}`;
+
+    // Check cache first
+    if (cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        renderPreviousClose(data);
+        return;
+    }
+
+    try {
+        const response = await fetch(`${API_BASE}/ticker/${ticker}/previous-close`);
+        const data = await response.json();
+
+        if (data.results && data.results.length > 0) {
+            cache.set(cacheKey, data, CACHE_TTL.DAILY);
+            renderPreviousClose(data);
+        }
+    } catch (error) {
+        console.error('Error loading previous close:', error);
+    }
+}
+
+function renderPreviousClose(data) {
+    if (data.results && data.results.length > 0) {
+        const result = data.results[0];
+        const priceElement = document.getElementById('stockPrice');
+        priceElement.textContent = `$${result.c.toFixed(2)}`;
+
+        const change = result.c - result.o;
+        const changePercent = ((change / result.o) * 100).toFixed(2);
+
+        if (change >= 0) {
+            priceElement.classList.add('positive');
+            priceElement.classList.remove('negative');
+            priceElement.innerHTML += ` <span style="font-size: 0.6em;">+${changePercent}%</span>`;
+        } else {
+            priceElement.classList.add('negative');
+            priceElement.classList.remove('positive');
+            priceElement.innerHTML += ` <span style="font-size: 0.6em;">${changePercent}%</span>`;
+        }
+
+        // Populate Overview metrics from previous close data
+        document.getElementById('openPrice').textContent = `$${result.o.toFixed(2)}`;
+        document.getElementById('highPrice').textContent = `$${result.h.toFixed(2)}`;
+        document.getElementById('lowPrice').textContent = `$${result.l.toFixed(2)}`;
+        document.getElementById('volume').textContent = formatLargeNumber(result.v);
+    }
+}
+
+async function loadChartData(ticker, range) {
+    const cacheKey = `chart_${ticker}_${range}`;
+    const chartLoading = document.getElementById('chartLoading');
+
+    // Check cache first
+    if (cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        if (data.results) {
+            renderChart(data.results);
+        }
+        return;
+    }
+
+    chartLoading.classList.remove('hidden');
+    const { from, to } = getDateRange(range);
+
+    try {
+        const response = await fetch(
+            `${API_BASE}/ticker/${ticker}/aggregates?from=${from}&to=${to}&timespan=day`
+        );
+        const data = await response.json();
+
+        if (data.results) {
+            cache.set(cacheKey, data, CACHE_TTL.DAILY);
+            renderChart(data.results);
+        }
+    } catch (error) {
+        console.error('Error loading chart data:', error);
+    } finally {
+        chartLoading.classList.add('hidden');
+    }
+}
+
+function getDateRange(range) {
+    const to = new Date();
+    const from = new Date();
+
+    switch(range) {
+        case '1M':
+            from.setMonth(from.getMonth() - 1);
+            break;
+        case '3M':
+            from.setMonth(from.getMonth() - 3);
+            break;
+        case '6M':
+            from.setMonth(from.getMonth() - 6);
+            break;
+        case '1Y':
+            from.setFullYear(from.getFullYear() - 1);
+            break;
+        case '5Y':
+            from.setFullYear(from.getFullYear() - 5);
+            break;
+    }
+
+    return {
+        from: from.toISOString().split('T')[0],
+        to: to.toISOString().split('T')[0]
+    };
+}
+
+// Chart state for interactivity
+let chartState = {
+    data: null,
+    canvas: null,
+    ctx: null,
+    padding: { top: 20, right: 20, bottom: 40, left: 65 },
+    hoveredIndex: -1,
+    animationProgress: 0,
+    animationFrame: null,
+    viewMode: 'line' // 'line' or 'candle'
+};
+
+function getChartColors() {
+    const isDark = document.documentElement.getAttribute('data-theme') === 'dark';
+    return {
+        line: isDark ? '#818cf8' : '#4f46e5',
+        lineLight: isDark ? '#a5b4fc' : '#6366f1',
+        gradientTop: isDark ? 'rgba(129, 140, 248, 0.3)' : 'rgba(79, 70, 229, 0.15)',
+        gradientBottom: isDark ? 'rgba(129, 140, 248, 0)' : 'rgba(79, 70, 229, 0)',
+        grid: isDark ? 'rgba(148, 163, 184, 0.1)' : 'rgba(148, 163, 184, 0.3)',
+        text: isDark ? '#94a3b8' : '#64748b',
+        textStrong: isDark ? '#cbd5e1' : '#475569',
+        crosshair: isDark ? 'rgba(148, 163, 184, 0.5)' : 'rgba(100, 116, 139, 0.4)',
+        tooltipBg: isDark ? '#1e293b' : '#ffffff',
+        tooltipBorder: isDark ? '#334155' : '#e2e8f0',
+        positive: '#10b981',
+        negative: '#ef4444'
+    };
+}
+
+function renderChart(data) {
+    const canvas = document.getElementById('priceChart');
+    const ctx = canvas.getContext('2d');
+
+    // High DPI support
+    const dpr = window.devicePixelRatio || 1;
+    const rect = canvas.getBoundingClientRect();
+    canvas.width = rect.width * dpr;
+    canvas.height = rect.height * dpr;
+    ctx.scale(dpr, dpr);
+    canvas.style.width = rect.width + 'px';
+    canvas.style.height = rect.height + 'px';
+
+    chartState.data = data;
+    chartState.canvas = canvas;
+    chartState.ctx = ctx;
+    chartState.hoveredIndex = -1;
+
+    // Cancel any existing animation
+    if (chartState.animationFrame) {
+        cancelAnimationFrame(chartState.animationFrame);
+    }
+
+    // Animate the chart drawing
+    chartState.animationProgress = 0;
+    animateChart();
+
+    // Set up mouse events
+    canvas.onmousemove = handleChartMouseMove;
+    canvas.onmouseleave = handleChartMouseLeave;
+}
+
+function animateChart() {
+    chartState.animationProgress += 0.04;
+    if (chartState.animationProgress > 1) chartState.animationProgress = 1;
+
+    drawChart(chartState.animationProgress);
+
+    if (chartState.animationProgress < 1) {
+        chartState.animationFrame = requestAnimationFrame(animateChart);
+    }
+}
+
+function drawChart(progress = 1) {
+    const { data, canvas, ctx, padding, viewMode } = chartState;
+    if (!data || !ctx) return;
+
+    const colors = getChartColors();
+    const dpr = window.devicePixelRatio || 1;
+    const width = canvas.width / dpr;
+    const height = canvas.height / dpr;
+    const chartWidth = width - padding.left - padding.right;
+    const chartHeight = height - padding.top - padding.bottom;
+
+    // For candlestick, use high/low for price range
+    let minPrice, maxPrice;
+    if (viewMode === 'candle') {
+        minPrice = Math.min(...data.map(d => d.l));
+        maxPrice = Math.max(...data.map(d => d.h));
+    } else {
+        const prices = data.map(d => d.c);
+        minPrice = Math.min(...prices);
+        maxPrice = Math.max(...prices);
+    }
+    const pricePadding = (maxPrice - minPrice) * 0.05;
+    const adjustedMin = minPrice - pricePadding;
+    const adjustedMax = maxPrice + pricePadding;
+    const priceRange = adjustedMax - adjustedMin;
+
+    ctx.clearRect(0, 0, width, height);
+
+    // Draw horizontal grid lines and Y-axis labels
+    const numGridLines = 5;
+    ctx.strokeStyle = colors.grid;
+    ctx.lineWidth = 1;
+    ctx.fillStyle = colors.text;
+    ctx.font = '11px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    ctx.textAlign = 'right';
+    ctx.textBaseline = 'middle';
+
+    for (let i = 0; i <= numGridLines; i++) {
+        const y = padding.top + (i / numGridLines) * chartHeight;
+        const price = adjustedMax - (i / numGridLines) * priceRange;
+
+        ctx.beginPath();
+        ctx.setLineDash([4, 4]);
+        ctx.moveTo(padding.left, y);
+        ctx.lineTo(width - padding.right, y);
+        ctx.stroke();
+        ctx.setLineDash([]);
+
+        ctx.fillText(`$${price.toFixed(2)}`, padding.left - 8, y);
+    }
+
+    // Draw chart based on view mode
+    if (viewMode === 'candle') {
+        drawCandlesticks(data, adjustedMax, priceRange, chartWidth, chartHeight, height, padding, colors, progress);
+    } else {
+        drawLineChart(data, adjustedMax, priceRange, chartWidth, chartHeight, height, padding, colors, progress);
+    }
+
+    // Draw X-axis date labels
+    drawXAxisLabels(data, chartWidth, height, padding, colors);
+
+    // Draw crosshair and tooltip if hovering
+    if (chartState.hoveredIndex >= 0 && chartState.hoveredIndex < data.length && progress === 1) {
+        drawCrosshair(chartState.hoveredIndex, data, adjustedMin, adjustedMax, priceRange, chartWidth, chartHeight, width, height, padding, colors);
+    }
+}
+
+function drawLineChart(data, adjustedMax, priceRange, chartWidth, chartHeight, height, padding, colors, progress) {
+    const ctx = chartState.ctx;
+
+    // Calculate points for animation
+    const pointsToDraw = Math.floor(data.length * progress);
+    const points = [];
+
+    for (let i = 0; i < pointsToDraw; i++) {
+        const x = padding.left + (i / (data.length - 1)) * chartWidth;
+        const y = padding.top + ((adjustedMax - data[i].c) / priceRange) * chartHeight;
+        points.push({ x, y, data: data[i] });
+    }
+
+    if (points.length < 2) return;
+
+    // Draw gradient fill
+    const gradient = ctx.createLinearGradient(0, padding.top, 0, height - padding.bottom);
+    gradient.addColorStop(0, colors.gradientTop);
+    gradient.addColorStop(1, colors.gradientBottom);
+
+    ctx.beginPath();
+    ctx.moveTo(points[0].x, height - padding.bottom);
+    points.forEach(p => ctx.lineTo(p.x, p.y));
+    ctx.lineTo(points[points.length - 1].x, height - padding.bottom);
+    ctx.closePath();
+    ctx.fillStyle = gradient;
+    ctx.fill();
+
+    // Draw the line
+    ctx.beginPath();
+    ctx.strokeStyle = colors.line;
+    ctx.lineWidth = 2;
+    ctx.lineJoin = 'round';
+    ctx.lineCap = 'round';
+
+    points.forEach((p, i) => {
+        if (i === 0) {
+            ctx.moveTo(p.x, p.y);
+        } else {
+            ctx.lineTo(p.x, p.y);
+        }
+    });
+    ctx.stroke();
+}
+
+function drawCandlesticks(data, adjustedMax, priceRange, chartWidth, chartHeight, height, padding, colors, progress) {
+    const ctx = chartState.ctx;
+    const candleCount = data.length;
+    const totalCandleSpace = chartWidth / candleCount;
+    const candleWidth = Math.max(1, totalCandleSpace * 0.7);
+    const candlesToDraw = Math.floor(candleCount * progress);
+
+    for (let i = 0; i < candlesToDraw; i++) {
+        const point = data[i];
+        const x = padding.left + (i + 0.5) * totalCandleSpace;
+
+        const openY = padding.top + ((adjustedMax - point.o) / priceRange) * chartHeight;
+        const closeY = padding.top + ((adjustedMax - point.c) / priceRange) * chartHeight;
+        const highY = padding.top + ((adjustedMax - point.h) / priceRange) * chartHeight;
+        const lowY = padding.top + ((adjustedMax - point.l) / priceRange) * chartHeight;
+
+        const isUp = point.c >= point.o;
+        const candleColor = isUp ? colors.positive : colors.negative;
+
+        // Draw wick (high to low line)
+        ctx.beginPath();
+        ctx.strokeStyle = candleColor;
+        ctx.lineWidth = 1;
+        ctx.moveTo(x, highY);
+        ctx.lineTo(x, lowY);
+        ctx.stroke();
+
+        // Draw body (open to close rectangle)
+        const bodyTop = Math.min(openY, closeY);
+        const bodyHeight = Math.max(1, Math.abs(closeY - openY));
+
+        ctx.fillStyle = candleColor;
+        ctx.fillRect(x - candleWidth / 2, bodyTop, candleWidth, bodyHeight);
+    }
+}
+
+function drawXAxisLabels(data, chartWidth, height, padding, colors) {
+    const ctx = chartState.ctx;
+    const labelCount = Math.min(6, data.length);
+    const step = Math.floor(data.length / labelCount);
+
+    ctx.fillStyle = colors.text;
+    ctx.font = '10px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'top';
+
+    for (let i = 0; i < data.length; i += step) {
+        const x = padding.left + (i / (data.length - 1)) * chartWidth;
+        const date = new Date(data[i].t);
+        const label = formatDateLabel(date, data.length);
+        ctx.fillText(label, x, height - padding.bottom + 8);
+    }
+
+    // Always show last date
+    const lastX = padding.left + chartWidth;
+    const lastDate = new Date(data[data.length - 1].t);
+    ctx.fillText(formatDateLabel(lastDate, data.length), lastX, height - padding.bottom + 8);
+}
+
+function formatDateLabel(date, dataLength) {
+    const month = date.toLocaleDateString('en-US', { month: 'short' });
+    const day = date.getDate();
+    const year = date.getFullYear().toString().slice(-2);
+
+    if (dataLength > 365) {
+        return `${month} '${year}`;
+    }
+    return `${month} ${day}`;
+}
+
+function drawCrosshair(index, data, adjustedMin, adjustedMax, priceRange, chartWidth, chartHeight, width, height, padding, colors) {
+    const ctx = chartState.ctx;
+    const point = data[index];
+    const x = padding.left + (index / (data.length - 1)) * chartWidth;
+    const y = padding.top + ((adjustedMax - point.c) / priceRange) * chartHeight;
+
+    // Vertical line
+    ctx.strokeStyle = colors.crosshair;
+    ctx.lineWidth = 1;
+    ctx.setLineDash([4, 4]);
+    ctx.beginPath();
+    ctx.moveTo(x, padding.top);
+    ctx.lineTo(x, height - padding.bottom);
+    ctx.stroke();
+
+    // Horizontal line
+    ctx.beginPath();
+    ctx.moveTo(padding.left, y);
+    ctx.lineTo(width - padding.right, y);
+    ctx.stroke();
+    ctx.setLineDash([]);
+
+    // Point dot
+    ctx.beginPath();
+    ctx.fillStyle = colors.line;
+    ctx.arc(x, y, 5, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.strokeStyle = colors.tooltipBg;
+    ctx.lineWidth = 2;
+    ctx.stroke();
+
+    // Tooltip
+    drawTooltip(x, y, point, data, index, width, height, padding, colors);
+}
+
+function drawTooltip(x, y, point, data, index, width, height, padding, colors) {
+    const ctx = chartState.ctx;
+    const isCandleMode = chartState.viewMode === 'candle';
+
+    const date = new Date(point.t);
+    const dateStr = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+
+    const change = index > 0 ? point.c - data[index - 1].c : 0;
+    const changePercent = index > 0 ? (change / data[index - 1].c) * 100 : 0;
+    const changeColor = change >= 0 ? colors.positive : colors.negative;
+    const changeSign = change >= 0 ? '+' : '';
+
+    const tooltipWidth = isCandleMode ? 155 : 140;
+    const tooltipHeight = isCandleMode ? 105 : 72;
+    let tooltipX = x + 12;
+    let tooltipY = y - tooltipHeight / 2;
+
+    // Keep tooltip in bounds
+    if (tooltipX + tooltipWidth > width - padding.right) {
+        tooltipX = x - tooltipWidth - 12;
+    }
+    if (tooltipY < padding.top) {
+        tooltipY = padding.top;
+    }
+    if (tooltipY + tooltipHeight > height - padding.bottom) {
+        tooltipY = height - padding.bottom - tooltipHeight;
+    }
+
+    // Tooltip background
+    ctx.fillStyle = colors.tooltipBg;
+    ctx.strokeStyle = colors.tooltipBorder;
+    ctx.lineWidth = 1;
+    ctx.beginPath();
+    ctx.roundRect(tooltipX, tooltipY, tooltipWidth, tooltipHeight, 6);
+    ctx.fill();
+    ctx.stroke();
+
+    // Tooltip content
+    ctx.fillStyle = colors.text;
+    ctx.font = '10px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    ctx.textAlign = 'left';
+    ctx.textBaseline = 'top';
+    ctx.fillText(dateStr, tooltipX + 10, tooltipY + 10);
+
+    if (isCandleMode) {
+        // OHLC display for candlestick mode
+        ctx.font = '11px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+        const ohlcY = tooltipY + 28;
+        const lineHeight = 16;
+
+        ctx.fillStyle = colors.text;
+        ctx.fillText('O:', tooltipX + 10, ohlcY);
+        ctx.fillText('H:', tooltipX + 10, ohlcY + lineHeight);
+        ctx.fillText('L:', tooltipX + 10, ohlcY + lineHeight * 2);
+        ctx.fillText('C:', tooltipX + 10, ohlcY + lineHeight * 3);
+
+        ctx.fillStyle = colors.textStrong;
+        ctx.fillText(`$${point.o.toFixed(2)}`, tooltipX + 28, ohlcY);
+        ctx.fillText(`$${point.h.toFixed(2)}`, tooltipX + 28, ohlcY + lineHeight);
+        ctx.fillText(`$${point.l.toFixed(2)}`, tooltipX + 28, ohlcY + lineHeight * 2);
+
+        ctx.fillStyle = changeColor;
+        ctx.fillText(`$${point.c.toFixed(2)}`, tooltipX + 28, ohlcY + lineHeight * 3);
+
+        // Change indicator on the right
+        ctx.fillStyle = changeColor;
+        ctx.textAlign = 'right';
+        ctx.fillText(`${changeSign}${changePercent.toFixed(2)}%`, tooltipX + tooltipWidth - 10, ohlcY + lineHeight * 3);
+    } else {
+        // Simple display for line chart
+        ctx.fillStyle = colors.textStrong;
+        ctx.font = 'bold 16px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+        ctx.fillText(`$${point.c.toFixed(2)}`, tooltipX + 10, tooltipY + 26);
+
+        ctx.fillStyle = changeColor;
+        ctx.font = '11px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+        ctx.fillText(`${changeSign}${change.toFixed(2)} (${changeSign}${changePercent.toFixed(2)}%)`, tooltipX + 10, tooltipY + 50);
+    }
+}
+
+function handleChartMouseMove(e) {
+    const { data, canvas, padding } = chartState;
+    if (!data) return;
+
+    const rect = canvas.getBoundingClientRect();
+    const dpr = window.devicePixelRatio || 1;
+    const width = canvas.width / dpr;
+    const chartWidth = width - padding.left - padding.right;
+    const mouseX = e.clientX - rect.left;
+
+    const relativeX = mouseX - padding.left;
+    const index = Math.round((relativeX / chartWidth) * (data.length - 1));
+
+    if (index >= 0 && index < data.length && index !== chartState.hoveredIndex) {
+        chartState.hoveredIndex = index;
+        drawChart(1);
+    }
+}
+
+function handleChartMouseLeave() {
+    chartState.hoveredIndex = -1;
+    drawChart(1);
+}
+
+async function loadFinancials(ticker) {
+    const cacheKey = `financials_${ticker}`;
+    const container = document.getElementById('financialsData');
+    container.innerHTML = '<p>Loading financial data...</p>';
+
+    // Check cache first
+    if (cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        renderFinancials(data, container);
+        return;
+    }
+
+    try {
+        const response = await fetch(`${API_BASE}/ticker/${ticker}/financials`);
+        const data = await response.json();
+
+        // Store in cache
+        cache.set(cacheKey, data, CACHE_TTL.MODERATE);
+
+        renderFinancials(data, container);
+    } catch (error) {
+        console.error('Error loading financials:', error);
+        container.innerHTML = '<p>Error loading financial data.</p>';
+    }
+}
+
+function renderFinancials(data, container) {
+    if (data.results && data.results.length > 0) {
+        let html = '';
+
+        data.results.forEach(period => {
+            const financials = period.financials;
+            const endDate = period.end_date ? new Date(period.end_date).toLocaleDateString() : '';
+            const dateDisplay = endDate ? ` (${endDate})` : '';
+
+            html += `
+                <div class="financial-period">
+                    <h4>${period.fiscal_year} - ${period.fiscal_period}${dateDisplay}</h4>
+                    <div class="financial-grid">
+            `;
+
+            if (financials.income_statement) {
+                const income = financials.income_statement;
+                if (income.revenues) {
+                    html += `
+                        <div class="financial-item">
+                            <span class="financial-item-label">Revenue</span>
+                            <span class="financial-item-value">${formatLargeNumber(income.revenues.value)}</span>
+                        </div>
+                    `;
+                }
+                if (income.net_income_loss) {
+                    html += `
+                        <div class="financial-item">
+                            <span class="financial-item-label">Net Income</span>
+                            <span class="financial-item-value">${formatLargeNumber(income.net_income_loss.value)}</span>
+                        </div>
+                    `;
+                }
+                if (income.gross_profit) {
+                    html += `
+                        <div class="financial-item">
+                            <span class="financial-item-label">Gross Profit</span>
+                            <span class="financial-item-value">${formatLargeNumber(income.gross_profit.value)}</span>
+                        </div>
+                    `;
+                }
+            }
+
+            if (financials.balance_sheet) {
+                const balance = financials.balance_sheet;
+                if (balance.assets) {
+                    html += `
+                        <div class="financial-item">
+                            <span class="financial-item-label">Total Assets</span>
+                            <span class="financial-item-value">${formatLargeNumber(balance.assets.value)}</span>
+                        </div>
+                    `;
+                }
+                if (balance.liabilities) {
+                    html += `
+                        <div class="financial-item">
+                            <span class="financial-item-label">Total Liabilities</span>
+                            <span class="financial-item-value">${formatLargeNumber(balance.liabilities.value)}</span>
+                        </div>
+                    `;
+                }
+            }
+
+            html += `
+                    </div>
+                </div>
+            `;
+        });
+
+        container.innerHTML = html;
+    } else {
+        container.innerHTML = '<p>No financial data available.</p>';
+    }
+}
+
+async function loadNews(ticker) {
+    const cacheKey = `news_${ticker}`;
+    const container = document.getElementById('newsContainer');
+    container.innerHTML = '<p>Loading news...</p>';
+
+    // Check cache first
+    if (cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        renderNews(data, container);
+        return;
+    }
+
+    try {
+        const response = await fetch(`${API_BASE}/ticker/${ticker}/news?limit=10`);
+        const data = await response.json();
+
+        // Store in cache
+        cache.set(cacheKey, data, CACHE_TTL.SHORT);
+
+        renderNews(data, container);
+
+        // Trigger article scraping in background
+        scrapeAndEmbedArticles();
+    } catch (error) {
+        console.error('Error loading news:', error);
+        container.innerHTML = '<p>Error loading news.</p>';
+    }
+}
+
+function renderNews(data, container) {
+    if (data.results && data.results.length > 0) {
+        let html = '';
+
+        data.results.forEach(article => {
+            const date = new Date(article.published_utc).toLocaleDateString();
+            html += `
+                <div class="news-article">
+                    <h4><a href="${article.article_url}" target="_blank">${article.title}</a></h4>
+                    <div class="news-meta">
+                        ${article.publisher?.name || 'Unknown'} - ${date}
+                    </div>
+                    <div class="news-description">
+                        ${article.description || ''}
+                    </div>
+                </div>
+            `;
+        });
+
+        container.innerHTML = html;
+    } else {
+        container.innerHTML = '<p>No news available.</p>';
+    }
+}
+
+function formatLargeNumber(num) {
+    if (num >= 1e12) return `$${(num / 1e12).toFixed(2)}T`;
+    if (num >= 1e9) return `$${(num / 1e9).toFixed(2)}B`;
+    if (num >= 1e6) return `$${(num / 1e6).toFixed(2)}M`;
+    if (num >= 1e3) return `$${(num / 1e3).toFixed(2)}K`;
+    return `$${num.toFixed(2)}`;
+}
+
+function showLoading(show) {
+    const loading = document.getElementById('loading');
+    if (show) {
+        loading.classList.remove('hidden');
+    } else {
+        loading.classList.add('hidden');
+    }
+}
+
+async function loadMarketStatus() {
+    const cacheKey = 'market_status';
+
+    // Check cache first
+    if (cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        renderMarketStatus(data);
+        return;
+    }
+
+    try {
+        const response = await fetch('http://localhost:5000/api/market-status');
+        const data = await response.json();
+
+        // Store in cache
+        cache.set(cacheKey, data, CACHE_TTL.DAILY);
+
+        renderMarketStatus(data);
+    } catch (error) {
+        console.error('Error loading market status:', error);
+        document.getElementById('marketStatusText').textContent = 'Unknown';
+    }
+}
+
+function renderMarketStatus(data) {
+    const statusText = document.getElementById('marketStatusText');
+    if (data.market === 'open') {
+        statusText.textContent = 'Open';
+        statusText.classList.add('status-open');
+        statusText.classList.remove('status-closed');
+    } else {
+        statusText.textContent = 'Closed';
+        statusText.classList.add('status-closed');
+        statusText.classList.remove('status-open');
+    }
+}
+
+async function loadDividends(ticker) {
+    const cacheKey = `dividends_${ticker}`;
+    const container = document.getElementById('dividendsContainer');
+    container.innerHTML = '<p>Loading dividend data...</p>';
+
+    // Check cache first
+    if (cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        renderDividends(data, container);
+        return;
+    }
+
+    try {
+        const response = await fetch(`${API_BASE}/ticker/${ticker}/dividends?limit=20`);
+        const data = await response.json();
+
+        // Store in cache
+        cache.set(cacheKey, data, CACHE_TTL.STATIC);
+
+        renderDividends(data, container);
+    } catch (error) {
+        console.error('Error loading dividends:', error);
+        container.innerHTML = '<p>Error loading dividend data.</p>';
+    }
+}
+
+function renderDividends(data, container) {
+    if (data.results && data.results.length > 0) {
+        let html = '<table class="data-table"><thead><tr>';
+        html += '<th>Ex-Dividend Date</th>';
+        html += '<th>Pay Date</th>';
+        html += '<th>Amount</th>';
+        html += '<th>Frequency</th>';
+        html += '</tr></thead><tbody>';
+
+        data.results.forEach(dividend => {
+            const exDate = new Date(dividend.ex_dividend_date).toLocaleDateString();
+            const payDate = dividend.pay_date ? new Date(dividend.pay_date).toLocaleDateString() : 'N/A';
+            const frequency = getFrequencyText(dividend.frequency);
+
+            html += '<tr>';
+            html += `<td>${exDate}</td>`;
+            html += `<td>${payDate}</td>`;
+            html += `<td>$${dividend.cash_amount.toFixed(4)}</td>`;
+            html += `<td>${frequency}</td>`;
+            html += '</tr>';
+        });
+
+        html += '</tbody></table>';
+        container.innerHTML = html;
+    } else {
+        container.innerHTML = '<p>No dividend data available for this stock.</p>';
+    }
+}
+
+async function loadSplits(ticker) {
+    const cacheKey = `splits_${ticker}`;
+    const container = document.getElementById('splitsContainer');
+    container.innerHTML = '<p>Loading stock split data...</p>';
+
+    // Check cache first
+    if (cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        renderSplits(data, container);
+        return;
+    }
+
+    try {
+        const response = await fetch(`${API_BASE}/ticker/${ticker}/splits?limit=20`);
+        const data = await response.json();
+
+        // Store in cache
+        cache.set(cacheKey, data, CACHE_TTL.STATIC);
+
+        renderSplits(data, container);
+    } catch (error) {
+        console.error('Error loading splits:', error);
+        container.innerHTML = '<p>Error loading stock split data.</p>';
+    }
+}
+
+function renderSplits(data, container) {
+    if (data.results && data.results.length > 0) {
+        let html = '<table class="data-table"><thead><tr>';
+        html += '<th>Execution Date</th>';
+        html += '<th>Split Ratio</th>';
+        html += '<th>Type</th>';
+        html += '</tr></thead><tbody>';
+
+        data.results.forEach(split => {
+            const execDate = new Date(split.execution_date).toLocaleDateString();
+            const ratio = `${split.split_to}:${split.split_from}`;
+            const type = split.split_from > split.split_to ? 'Reverse Split' : 'Forward Split';
+
+            html += '<tr>';
+            html += `<td>${execDate}</td>`;
+            html += `<td>${ratio}</td>`;
+            html += `<td>${type}</td>`;
+            html += '</tr>';
+        });
+
+        html += '</tbody></table>';
+        container.innerHTML = html;
+    } else {
+        container.innerHTML = '<p>No stock split data available for this stock.</p>';
+    }
+}
+
+function getFrequencyText(frequency) {
+    const frequencies = {
+        0: 'One-time',
+        1: 'Annual',
+        2: 'Semi-Annual',
+        4: 'Quarterly',
+        12: 'Monthly',
+        24: 'Bi-Monthly',
+        52: 'Weekly'
+    };
+    return frequencies[frequency] || 'Unknown';
+}
+
+// ============================================
+// CHAT FUNCTIONALITY
+// ============================================
+
+// Chat state management
+let chatState = {
+    conversationId: generateUUID(),
+    messages: [],
+    isOpen: true,  // Default to open for persistent panel
+    isLoading: false
+};
+
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
+
+function updateChatContext() {
+    const contextEl = document.getElementById('chatCurrentTicker');
+
+    if (currentTicker) {
+        const detailsCache = cache.get(`details_${currentTicker}`);
+        const companyName = detailsCache?.results?.name || currentTicker;
+        contextEl.textContent = `${currentTicker} - ${companyName}`;
+    } else {
+        contextEl.textContent = 'Select a stock to start';
+    }
+}
+
+// Tool display names for status indicators
+const TOOL_DISPLAY_NAMES = {
+    'get_stock_quote': 'Fetching stock price',
+    'get_company_info': 'Looking up company info',
+    'get_financials': 'Retrieving financial data',
+    'get_news': 'Searching news articles',
+    'search_knowledge_base': 'Searching knowledge base',
+    'analyze_sentiment': 'Analyzing social sentiment',
+    'get_price_forecast': 'Generating price forecast',
+    'get_dividends': 'Fetching dividend history',
+    'get_stock_splits': 'Checking split history',
+    'get_price_history': 'Loading price history'
+};
+
+function parseSSEBuffer(buffer) {
+    const parsed = [];
+    const lines = buffer.split('\n');
+    let currentEvent = { type: null, data: null };
+    let remaining = '';
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        if (line.startsWith('event: ')) {
+            currentEvent.type = line.substring(7).trim();
+        } else if (line.startsWith('data: ')) {
+            currentEvent.data = line.substring(6);
+        } else if (line === '' && currentEvent.type !== null) {
+            let data = currentEvent.data;
+            if (currentEvent.type !== 'text') {
+                try { data = JSON.parse(data); } catch (e) {}
+            }
+            parsed.push({ type: currentEvent.type, data: data });
+            currentEvent = { type: null, data: null };
+        }
+    }
+
+    // Keep incomplete event in buffer
+    if (currentEvent.type !== null || currentEvent.data !== null) {
+        remaining = '';
+        if (currentEvent.type) remaining += `event: ${currentEvent.type}\n`;
+        if (currentEvent.data !== null) remaining += `data: ${currentEvent.data}\n`;
+    }
+
+    return { parsed, remaining };
+}
+
+function renderToolStatuses(elementId, statuses) {
+    const el = document.getElementById(elementId);
+    if (!el) return;
+
+    let html = '';
+    for (const status of statuses) {
+        const icon = status.status === 'complete' ? '&#10003;' :
+                     status.status === 'error' ? '&#10007;' :
+                     '<span class="tool-spinner"></span>';
+        const className = `tool-status-item ${status.status}`;
+        html += `<div class="${className}">${icon} ${escapeHtml(status.displayName)}</div>`;
+    }
+    el.innerHTML = html;
+    el.scrollIntoView({ behavior: 'smooth', block: 'end' });
+}
+
+async function sendChatMessage() {
+    const input = document.getElementById('chatInput');
+    const message = input.value.trim();
+
+    if (!message) return;
+
+    if (!currentTicker) {
+        addMessageToChat('error', 'Please select a stock first.');
+        return;
+    }
+
+    // Add user message to UI
+    addMessageToChat('user', message);
+    input.value = '';
+
+    // Disable input while processing
+    input.disabled = true;
+    document.getElementById('sendChatBtn').disabled = true;
+
+    // Show loading indicator
+    const loadingId = addMessageToChat('loading', '');
+
+    // Collect current stock context from cache (for agent's hybrid caching)
+    const context = {
+        overview: {
+            details: cache.get(`details_${currentTicker}`),
+            previousClose: cache.get(`prev_close_${currentTicker}`)
+        },
+        financials: cache.get(`financials_${currentTicker}`),
+        news: cache.get(`news_${currentTicker}`),
+        dividends: cache.get(`dividends_${currentTicker}`),
+        splits: cache.get(`splits_${currentTicker}`),
+        sentiment: cache.get(`sentiment_${currentTicker}`)
+    };
+
+    try {
+        const response = await fetch(`${API_BASE}/chat/message`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                ticker: currentTicker,
+                message: message,
+                context: context,
+                conversation_id: chatState.conversationId
+            })
+        });
+
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+
+        // Remove loading indicator
+        removeMessage(loadingId);
+
+        // Create tool status container and assistant message container
+        const toolStatusId = addMessageToChat('tool-status', '');
+        let toolStatuses = [];
+        const messageId = addMessageToChat('assistant', '');
+        let assistantMessage = '';
+
+        // Parse structured SSE events
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            buffer += decoder.decode(value, { stream: true });
+            const result = parseSSEBuffer(buffer);
+            buffer = result.remaining;
+
+            for (const event of result.parsed) {
+                if (event.type === 'tool_call') {
+                    const displayName = TOOL_DISPLAY_NAMES[event.data.tool] || event.data.tool;
+
+                    if (event.data.status === 'calling') {
+                        toolStatuses.push({ tool: event.data.tool, displayName, status: 'calling' });
+                    } else {
+                        const existing = toolStatuses.find(t => t.tool === event.data.tool);
+                        if (existing) existing.status = event.data.status;
+                    }
+                    renderToolStatuses(toolStatusId, toolStatuses);
+
+                } else if (event.type === 'text') {
+                    assistantMessage += event.data;
+                    updateMessage(messageId, assistantMessage);
+
+                } else if (event.type === 'done') {
+                    // Fade out tool statuses
+                    const toolEl = document.getElementById(toolStatusId);
+                    if (toolEl && toolStatuses.length > 0) {
+                        toolEl.classList.add('tool-status-complete');
+                    }
+
+                } else if (event.type === 'error') {
+                    removeMessage(messageId);
+                    addMessageToChat('error', event.data.message || 'An error occurred');
+                }
+            }
+        }
+
+        // Remove tool status container if no tools were called
+        if (toolStatuses.length === 0) {
+            removeMessage(toolStatusId);
+        }
+
+        // Save to chat state
+        chatState.messages.push(
+            { role: 'user', content: message },
+            { role: 'assistant', content: assistantMessage }
+        );
+
+    } catch (error) {
+        console.error('Chat error:', error);
+        removeMessage(loadingId);
+        addMessageToChat('error', 'Failed to get response. Please try again.');
+    } finally {
+        input.disabled = false;
+        document.getElementById('sendChatBtn').disabled = false;
+        input.focus();
+    }
+}
+
+function addMessageToChat(type, content) {
+    const container = document.getElementById('chatMessages');
+    const messageId = generateUUID();
+
+    const messageDiv = document.createElement('div');
+    messageDiv.id = messageId;
+    messageDiv.className = `message ${type}`;
+
+    if (type === 'loading') {
+        messageDiv.innerHTML = '<div class="typing-indicator"><span></span><span></span><span></span></div>';
+    } else {
+        messageDiv.textContent = content;
+    }
+
+    container.appendChild(messageDiv);
+    messageDiv.scrollIntoView({ behavior: 'smooth', block: 'end' });
+
+    return messageId;
+}
+
+function updateMessage(messageId, content) {
+    const messageDiv = document.getElementById(messageId);
+    if (messageDiv) {
+        messageDiv.textContent = content;
+        messageDiv.scrollIntoView({ behavior: 'smooth', block: 'end' });
+    }
+}
+
+function removeMessage(messageId) {
+    const messageDiv = document.getElementById(messageId);
+    if (messageDiv) {
+        messageDiv.remove();
+    }
+}
+
+// Preload news data and trigger RAG scraping when stock is selected
+async function preloadNewsForRAG(ticker) {
+    const cacheKey = `news_${ticker}`;
+
+    // Skip if already cached
+    if (cache.has(cacheKey)) {
+        // Trigger scraping with cached data
+        scrapeAndEmbedArticles();
+        return;
+    }
+
+    try {
+        const response = await fetch(`${API_BASE}/ticker/${ticker}/news?limit=10`);
+        const data = await response.json();
+
+        // Store in cache
+        cache.set(cacheKey, data, CACHE_TTL.SHORT);
+
+        // Trigger article scraping in background
+        scrapeAndEmbedArticles();
+    } catch (error) {
+        console.error('Error preloading news for RAG:', error);
+    }
+}
+
+// Background job to scrape and embed articles when News tab is loaded
+async function scrapeAndEmbedArticles() {
+    if (!currentTicker) return;
+
+    const newsCache = cache.get(`news_${currentTicker}`);
+    if (!newsCache || !newsCache.results) return;
+
+    try {
+        // Call scrape endpoint in background (don't await)
+        fetch(`${API_BASE}/chat/scrape-articles`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                ticker: currentTicker,
+                articles: newsCache.results
+            })
+        }).then(response => response.json())
+          .then(result => {
+              console.log('Article scraping complete:', result);
+          })
+          .catch(error => {
+              console.error('Article scraping error:', error);
+          });
+    } catch (error) {
+        console.error('Failed to initiate article scraping:', error);
+    }
+}
+
+// Setup chat event listeners
+function setupChatListeners() {
+    // Mobile chat toggle button
+    const mobileToggle = document.getElementById('mobileChatToggle');
+    if (mobileToggle) {
+        mobileToggle.addEventListener('click', toggleMobileChat);
+    }
+
+    // Mobile chat close button
+    const mobileClose = document.getElementById('closeMobileChat');
+    if (mobileClose) {
+        mobileClose.addEventListener('click', toggleMobileChat);
+    }
+
+    // Send button and input
+    document.getElementById('sendChatBtn').addEventListener('click', sendChatMessage);
+
+    document.getElementById('chatInput').addEventListener('keydown', (e) => {
+        if (e.key === 'Enter' && !e.shiftKey) {
+            e.preventDefault();
+            sendChatMessage();
+        }
+    });
+
+    // Setup sentiment listeners
+    setupSentimentListeners();
+
+    // Setup forecast listeners
+    setupForecastListeners();
+}
+
+// Toggle chat for mobile (full screen overlay)
+function toggleMobileChat() {
+    const chatPanel = document.getElementById('chatPanel');
+    const isOpen = chatPanel.classList.contains('open');
+
+    if (isOpen) {
+        chatPanel.classList.remove('open');
+    } else {
+        chatPanel.classList.add('open');
+        updateChatContext();
+    }
+}
+
+// ============================================
+// SENTIMENT ANALYSIS FUNCTIONALITY
+// ============================================
+
+let sentimentState = {
+    currentFilter: 'all',
+    posts: [],
+    isLoading: false
+};
+
+function setupSentimentListeners() {
+    // Filter buttons
+    const filterBtns = document.querySelectorAll('.posts-filter .filter-btn');
+    filterBtns.forEach(btn => {
+        btn.addEventListener('click', () => {
+            filterBtns.forEach(b => b.classList.remove('active'));
+            btn.classList.add('active');
+            sentimentState.currentFilter = btn.dataset.filter;
+            renderSentimentPosts(sentimentState.posts);
+        });
+    });
+
+    // Refresh button
+    const refreshBtn = document.getElementById('sentimentRefreshBtn');
+    if (refreshBtn) {
+        refreshBtn.addEventListener('click', () => {
+            if (currentTicker && !sentimentState.isLoading) {
+                loadSentiment(currentTicker, true);
+            }
+        });
+    }
+}
+
+async function loadSentiment(ticker, forceRefresh = false) {
+    const cacheKey = `sentiment_${ticker}`;
+    const container = document.getElementById('sentimentPostsContainer');
+    const refreshBtn = document.getElementById('sentimentRefreshBtn');
+
+    // Show loading state
+    container.innerHTML = '<p class="loading-text">Analyzing social media sentiment...</p>';
+
+    sentimentState.isLoading = true;
+    if (refreshBtn) {
+        refreshBtn.disabled = true;
+        refreshBtn.classList.add('loading');
+    }
+
+    // Check cache first (skip if force refresh)
+    if (!forceRefresh && cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        renderSentiment(data);
+        sentimentState.isLoading = false;
+        if (refreshBtn) {
+            refreshBtn.disabled = false;
+            refreshBtn.classList.remove('loading');
+        }
+        return;
+    }
+
+    try {
+        const response = await fetch(`${API_BASE}/sentiment/analyze`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ ticker: ticker, force_refresh: forceRefresh })
+        });
+
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+
+        const data = await response.json();
+
+        // Cache with short TTL (15 minutes)
+        cache.set(cacheKey, data, CACHE_TTL.SHORT);
+
+        renderSentiment(data);
+
+    } catch (error) {
+        console.error('Error loading sentiment:', error);
+        container.innerHTML = '<p class="error-text">Error loading sentiment data. Please try again.</p>';
+        resetSentimentUI();
+    } finally {
+        sentimentState.isLoading = false;
+        if (refreshBtn) {
+            refreshBtn.disabled = false;
+            refreshBtn.classList.remove('loading');
+        }
+    }
+}
+
+function renderSentiment(data) {
+    const aggregate = data.aggregate;
+
+    // Update gauge
+    updateSentimentGauge(aggregate.score);
+
+    // Update label and confidence
+    const labelEl = document.getElementById('sentimentLabel');
+    labelEl.textContent = aggregate.label.toUpperCase();
+    labelEl.className = 'sentiment-label ' + aggregate.label;
+
+    // Update stats
+    document.getElementById('sentimentPostCount').textContent = aggregate.post_count;
+    document.getElementById('sentimentLastUpdated').textContent = new Date().toLocaleTimeString();
+
+    // Update source breakdown
+    const sources = aggregate.sources || {};
+    updateSourceItem('stocktwitsSource', sources.stocktwits || 0, aggregate.post_count);
+    updateSourceItem('redditSource', sources.reddit || 0, aggregate.post_count);
+    updateSourceItem('twitterSource', sources.twitter || 0, aggregate.post_count);
+
+    // Store posts and render
+    sentimentState.posts = data.posts || [];
+    renderSentimentPosts(sentimentState.posts);
+}
+
+function updateSentimentGauge(score) {
+    // Score ranges from -1 (bearish) to +1 (bullish)
+    // Map to rotation: -90deg (bearish) to +90deg (bullish)
+    const rotation = score * 90;
+
+    const needle = document.getElementById('gaugeNeedle');
+    if (needle) {
+        needle.style.transform = `rotate(${rotation}deg)`;
+    }
+
+    // Update gauge fill color based on sentiment
+    const fill = document.getElementById('gaugeFill');
+    if (fill) {
+        if (score > 0.2) {
+            fill.className = 'gauge-fill bullish';
+        } else if (score < -0.2) {
+            fill.className = 'gauge-fill bearish';
+        } else {
+            fill.className = 'gauge-fill neutral';
+        }
+    }
+}
+
+function updateSourceItem(elementId, count, total) {
+    const element = document.getElementById(elementId);
+    if (!element) return;
+
+    const countEl = element.querySelector('.source-count');
+    if (countEl) {
+        countEl.textContent = count;
+    }
+}
+
+function renderSentimentPosts(posts) {
+    const container = document.getElementById('sentimentPostsContainer');
+
+    if (!posts || posts.length === 0) {
+        container.innerHTML = '<p class="no-data-text">No sentiment data available for this stock.</p>';
+        return;
+    }
+
+    // Apply filter
+    let filteredPosts = posts;
+    if (sentimentState.currentFilter !== 'all') {
+        filteredPosts = posts.filter(post => {
+            const label = post.sentiment?.label || 'neutral';
+            return label === sentimentState.currentFilter;
+        });
+    }
+
+    if (filteredPosts.length === 0) {
+        container.innerHTML = `<p class="no-data-text">No ${sentimentState.currentFilter} posts found.</p>`;
+        return;
+    }
+
+    let html = '';
+    filteredPosts.forEach(post => {
+        const sentimentLabel = post.sentiment?.label || 'neutral';
+        const sentimentScore = post.sentiment?.score || 0;
+        const scorePercent = (sentimentScore * 100).toFixed(0);
+        const timestamp = post.timestamp ? formatRelativeTime(post.timestamp) : '';
+        const platform = post.platform || 'unknown';
+        const engagement = post.engagement || {};
+
+        html += `
+            <div class="sentiment-post ${sentimentLabel}">
+                <div class="post-header">
+                    <span class="post-platform">${getPlatformIcon(platform)} ${platform}</span>
+                    <span class="post-sentiment ${sentimentLabel}">
+                        ${sentimentLabel} (${scorePercent}%)
+                    </span>
+                </div>
+                <p class="post-content">${escapeHtml(post.content || '')}</p>
+                <div class="post-meta">
+                    <span class="post-author">@${escapeHtml(post.author || 'unknown')}</span>
+                    <span class="post-time">${timestamp}</span>
+                    <span class="post-engagement">
+                        ${engagement.likes || 0} likes ${engagement.comments ? `· ${engagement.comments} comments` : ''}
+                    </span>
+                </div>
+                ${post.url ? `<a href="${post.url}" target="_blank" class="post-link">View original</a>` : ''}
+            </div>
+        `;
+    });
+
+    container.innerHTML = html;
+}
+
+function getPlatformIcon(platform) {
+    const icons = {
+        'stocktwits': '📈',
+        'reddit': '👽',
+        'twitter': '🐦'
+    };
+    return icons[platform] || '💬';
+}
+
+function formatRelativeTime(timestamp) {
+    try {
+        const date = new Date(timestamp);
+        const now = new Date();
+        const diffMs = now - date;
+        const diffMins = Math.floor(diffMs / 60000);
+        const diffHours = Math.floor(diffMs / 3600000);
+        const diffDays = Math.floor(diffMs / 86400000);
+
+        if (diffMins < 1) return 'just now';
+        if (diffMins < 60) return `${diffMins}m ago`;
+        if (diffHours < 24) return `${diffHours}h ago`;
+        if (diffDays < 7) return `${diffDays}d ago`;
+        return date.toLocaleDateString();
+    } catch {
+        return '';
+    }
+}
+
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+function resetSentimentUI() {
+    document.getElementById('sentimentLabel').textContent = '--';
+    document.getElementById('sentimentLabel').className = 'sentiment-label';
+    document.getElementById('sentimentConfidence').textContent = '--';
+    document.getElementById('sentimentPostCount').textContent = '--';
+    document.getElementById('sentimentLastUpdated').textContent = '--';
+
+    updateSourceItem('stocktwitsSource', 0, 0);
+    updateSourceItem('redditSource', 0, 0);
+    updateSourceItem('twitterSource', 0, 0);
+
+    const needle = document.getElementById('gaugeNeedle');
+    if (needle) {
+        needle.style.transform = 'rotate(0deg)';
+    }
+}
+
+// ============================================
+// FORECAST FUNCTIONALITY
+// ============================================
+
+let forecastState = {
+    data: null,
+    isLoading: false,
+    modelStatus: null
+};
+
+let forecastChartState = {
+    data: null,
+    canvas: null,
+    ctx: null,
+    padding: { top: 20, right: 20, bottom: 40, left: 65 },
+    hoveredIndex: -1,
+    totalPoints: 0,
+    historicalLength: 0
+};
+
+function setupForecastListeners() {
+    const refreshBtn = document.getElementById('forecastRefreshBtn');
+    if (refreshBtn) {
+        refreshBtn.addEventListener('click', () => {
+            if (currentTicker && !forecastState.isLoading) {
+                loadForecast(currentTicker, true);
+            }
+        });
+    }
+}
+
+async function getHistoricalDataForForecast(ticker) {
+    // Try to get 2-year data from cache first (used for training)
+    const cacheKey2Y = `chart_${ticker}_2Y`;
+    if (cache.has(cacheKey2Y)) {
+        const data = cache.get(cacheKey2Y);
+        if (data.results && data.results.length > 0) {
+            return data.results;
+        }
+    }
+
+    // Try 5-year cache as fallback (has more than enough data)
+    const cacheKey5Y = `chart_${ticker}_5Y`;
+    if (cache.has(cacheKey5Y)) {
+        const data = cache.get(cacheKey5Y);
+        if (data.results && data.results.length > 0) {
+            return data.results;
+        }
+    }
+
+    // Try 1-year cache (minimum for decent training)
+    const cacheKey1Y = `chart_${ticker}_1Y`;
+    if (cache.has(cacheKey1Y)) {
+        const data = cache.get(cacheKey1Y);
+        if (data.results && data.results.length > 0) {
+            return data.results;
+        }
+    }
+
+    // No cached data available, fetch 2 years of data
+    const to = new Date();
+    const from = new Date();
+    from.setFullYear(from.getFullYear() - 2);
+
+    const fromStr = from.toISOString().split('T')[0];
+    const toStr = to.toISOString().split('T')[0];
+
+    try {
+        const response = await fetch(
+            `${API_BASE}/ticker/${ticker}/aggregates?from=${fromStr}&to=${toStr}&timespan=day`
+        );
+        const data = await response.json();
+
+        // Cache it for future use
+        if (data.results) {
+            cache.set(cacheKey2Y, data, CACHE_TTL.DAILY);
+            return data.results;
+        }
+    } catch (error) {
+        console.error('Error fetching historical data for forecast:', error);
+    }
+
+    return null;
+}
+
+async function loadForecast(ticker, forceRefresh = false) {
+    const cacheKey = `forecast_${ticker}`;
+    const container = document.getElementById('forecastTableContainer');
+    const refreshBtn = document.getElementById('forecastRefreshBtn');
+
+    // Show loading state
+    container.innerHTML = '<p class="loading-text">Loading forecast...</p>';
+
+    forecastState.isLoading = true;
+    if (refreshBtn) {
+        refreshBtn.disabled = true;
+        refreshBtn.classList.add('loading');
+    }
+
+    // Update status to show loading
+    document.getElementById('forecastModelStatus').textContent = 'Loading...';
+
+    // Check cache first (skip if force refresh)
+    if (!forceRefresh && cache.has(cacheKey)) {
+        const data = cache.get(cacheKey);
+        renderForecast(data);
+        forecastState.isLoading = false;
+        if (refreshBtn) {
+            refreshBtn.disabled = false;
+            refreshBtn.classList.remove('loading');
+        }
+        return;
+    }
+
+    try {
+        // Get historical data from cache or fetch it (reuse existing chart data)
+        const historicalData = await getHistoricalDataForForecast(ticker);
+
+        const response = await fetch(`${API_BASE}/forecast/predict/${ticker}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                historical_data: historicalData,
+                force_retrain: forceRefresh
+            })
+        });
+
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.error || 'Forecast failed');
+        }
+
+        const data = await response.json();
+        cache.set(cacheKey, data, CACHE_TTL.MODERATE);
+        renderForecast(data);
+
+    } catch (error) {
+        console.error('Error loading forecast:', error);
+        container.innerHTML = `<p class="error-text">${error.message || 'Error loading forecast'}</p>`;
+        resetForecastUI();
+    } finally {
+        forecastState.isLoading = false;
+        if (refreshBtn) {
+            refreshBtn.disabled = false;
+            refreshBtn.classList.remove('loading');
+        }
+    }
+}
+
+function renderForecast(data) {
+    forecastState.data = data;
+
+    // Clear loading text
+    document.getElementById('forecastTableContainer').innerHTML = '';
+
+    // Update status
+    if (data.model_info) {
+        document.getElementById('forecastModelStatus').textContent = 'Trained';
+        const trainedAt = data.model_info.trained_at;
+        if (trainedAt) {
+            const date = new Date(trainedAt);
+            document.getElementById('forecastLastUpdated').textContent = date.toLocaleDateString();
+        }
+    } else {
+        document.getElementById('forecastModelStatus').textContent = 'Not trained';
+    }
+
+    // Draw forecast chart
+    drawForecastChart(data);
+
+}
+
+function drawForecastChart(data, skipSetup = false) {
+    const canvas = document.getElementById('forecastChart');
+    if (!canvas) return;
+
+    const ctx = canvas.getContext('2d');
+    const colors = getChartColors();
+
+    // High DPI support
+    const dpr = window.devicePixelRatio || 1;
+    const rect = canvas.getBoundingClientRect();
+
+    if (!skipSetup) {
+        canvas.width = rect.width * dpr;
+        canvas.height = rect.height * dpr;
+        ctx.scale(dpr, dpr);
+        canvas.style.width = rect.width + 'px';
+        canvas.style.height = rect.height + 'px';
+    }
+
+    const padding = { top: 20, right: 20, bottom: 40, left: 65 };
+    const width = rect.width;
+    const height = rect.height;
+    const chartWidth = width - padding.left - padding.right;
+    const chartHeight = height - padding.top - padding.bottom;
+
+    // Combine historical and forecast data
+    const historical = data.historical || [];
+    const forecast = data.forecast || [];
+    const confidenceBounds = data.confidence_bounds || {};
+
+    if (historical.length === 0 && forecast.length === 0) {
+        ctx.fillStyle = colors.text;
+        ctx.font = '14px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+        ctx.textAlign = 'center';
+        ctx.fillText('No data available', width / 2, height / 2);
+        return;
+    }
+
+    // Store state for hover interactions
+    forecastChartState.data = data;
+    forecastChartState.canvas = canvas;
+    forecastChartState.ctx = ctx;
+    forecastChartState.totalPoints = historical.length + forecast.length;
+    forecastChartState.historicalLength = historical.length;
+
+    // Calculate price range
+    const historicalPrices = historical.map(d => d.close);
+    const forecastPrices = forecast.map(d => d.predicted_close);
+    const upperBound = confidenceBounds.upper || [];
+    const lowerBound = confidenceBounds.lower || [];
+
+    const allPrices = [...historicalPrices, ...forecastPrices, ...upperBound, ...lowerBound];
+    const minPrice = Math.min(...allPrices);
+    const maxPrice = Math.max(...allPrices);
+    const pricePadding = (maxPrice - minPrice) * 0.1;
+    const adjustedMin = minPrice - pricePadding;
+    const adjustedMax = maxPrice + pricePadding;
+    const priceRange = adjustedMax - adjustedMin;
+
+    const totalPoints = historical.length + forecast.length;
+
+    ctx.clearRect(0, 0, width, height);
+
+    // Draw grid lines
+    const numGridLines = 5;
+    ctx.strokeStyle = colors.grid;
+    ctx.lineWidth = 1;
+    ctx.fillStyle = colors.text;
+    ctx.font = '11px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    ctx.textAlign = 'right';
+    ctx.textBaseline = 'middle';
+
+    for (let i = 0; i <= numGridLines; i++) {
+        const y = padding.top + (i / numGridLines) * chartHeight;
+        const price = adjustedMax - (i / numGridLines) * priceRange;
+
+        ctx.beginPath();
+        ctx.setLineDash([4, 4]);
+        ctx.moveTo(padding.left, y);
+        ctx.lineTo(width - padding.right, y);
+        ctx.stroke();
+        ctx.setLineDash([]);
+
+        ctx.fillText(`$${price.toFixed(2)}`, padding.left - 8, y);
+    }
+
+    // Draw vertical divider line between historical and forecast
+    if (historical.length > 0 && forecast.length > 0) {
+        const dividerX = padding.left + (historical.length / totalPoints) * chartWidth;
+        ctx.strokeStyle = colors.crosshair;
+        ctx.lineWidth = 1;
+        ctx.setLineDash([8, 4]);
+        ctx.beginPath();
+        ctx.moveTo(dividerX, padding.top);
+        ctx.lineTo(dividerX, height - padding.bottom);
+        ctx.stroke();
+        ctx.setLineDash([]);
+    }
+
+    // Draw confidence band (shaded area)
+    if (upperBound.length > 0 && lowerBound.length > 0) {
+        ctx.beginPath();
+        ctx.fillStyle = 'rgba(16, 185, 129, 0.15)';
+
+        // Start from first forecast point
+        const startIdx = historical.length;
+        for (let i = 0; i < forecast.length; i++) {
+            const x = padding.left + ((startIdx + i) / (totalPoints - 1)) * chartWidth;
+            const y = padding.top + ((adjustedMax - upperBound[i]) / priceRange) * chartHeight;
+            if (i === 0) ctx.moveTo(x, y);
+            else ctx.lineTo(x, y);
+        }
+
+        // Go back along lower bound
+        for (let i = forecast.length - 1; i >= 0; i--) {
+            const x = padding.left + ((startIdx + i) / (totalPoints - 1)) * chartWidth;
+            const y = padding.top + ((adjustedMax - lowerBound[i]) / priceRange) * chartHeight;
+            ctx.lineTo(x, y);
+        }
+
+        ctx.closePath();
+        ctx.fill();
+    }
+
+    // Draw historical line
+    if (historical.length > 1) {
+        ctx.beginPath();
+        ctx.strokeStyle = colors.line;
+        ctx.lineWidth = 2;
+        ctx.lineJoin = 'round';
+        ctx.lineCap = 'round';
+
+        historical.forEach((d, i) => {
+            const x = padding.left + (i / (totalPoints - 1)) * chartWidth;
+            const y = padding.top + ((adjustedMax - d.close) / priceRange) * chartHeight;
+            if (i === 0) ctx.moveTo(x, y);
+            else ctx.lineTo(x, y);
+        });
+        ctx.stroke();
+    }
+
+    // Draw forecast line (dashed)
+    if (forecast.length > 0) {
+        ctx.beginPath();
+        ctx.strokeStyle = colors.positive;
+        ctx.lineWidth = 2;
+        ctx.setLineDash([6, 4]);
+        ctx.lineJoin = 'round';
+        ctx.lineCap = 'round';
+
+        // Connect from last historical point
+        if (historical.length > 0) {
+            const lastHistorical = historical[historical.length - 1];
+            const x = padding.left + ((historical.length - 1) / (totalPoints - 1)) * chartWidth;
+            const y = padding.top + ((adjustedMax - lastHistorical.close) / priceRange) * chartHeight;
+            ctx.moveTo(x, y);
+        }
+
+        forecast.forEach((d, i) => {
+            const x = padding.left + ((historical.length + i) / (totalPoints - 1)) * chartWidth;
+            const y = padding.top + ((adjustedMax - d.predicted_close) / priceRange) * chartHeight;
+            if (historical.length === 0 && i === 0) ctx.moveTo(x, y);
+            else ctx.lineTo(x, y);
+        });
+        ctx.stroke();
+        ctx.setLineDash([]);
+    }
+
+    // Draw X-axis labels
+    ctx.fillStyle = colors.text;
+    ctx.font = '10px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'top';
+
+    // Show a few date labels
+    const allDates = [...historical.map(d => d.date), ...forecast.map(d => d.date)];
+    const labelIndices = [0, Math.floor(historical.length / 2), historical.length - 1, historical.length + Math.floor(forecast.length / 2), totalPoints - 1];
+
+    labelIndices.forEach(idx => {
+        if (idx >= 0 && idx < allDates.length) {
+            const x = padding.left + (idx / (totalPoints - 1)) * chartWidth;
+            const date = new Date(allDates[idx]);
+            const label = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+            ctx.fillText(label, x, height - padding.bottom + 8);
+        }
+    });
+
+    // Draw crosshair and tooltip if hovering
+    if (forecastChartState.hoveredIndex >= 0 && forecastChartState.hoveredIndex < totalPoints) {
+        drawForecastCrosshair(forecastChartState.hoveredIndex, data, adjustedMin, adjustedMax, priceRange, chartWidth, chartHeight, width, height, padding, colors);
+    }
+
+    // Set up mouse events (only on initial draw)
+    if (!skipSetup) {
+        canvas.onmousemove = handleForecastChartMouseMove;
+        canvas.onmouseleave = handleForecastChartMouseLeave;
+    }
+}
+
+function drawForecastCrosshair(index, data, adjustedMin, adjustedMax, priceRange, chartWidth, chartHeight, width, height, padding, colors) {
+    const ctx = forecastChartState.ctx;
+    const historical = data.historical || [];
+    const forecast = data.forecast || [];
+    const totalPoints = historical.length + forecast.length;
+
+    // Determine if we're in historical or forecast region
+    const isHistorical = index < historical.length;
+    let point, price, date;
+
+    if (isHistorical) {
+        point = historical[index];
+        price = point.close;
+        date = point.date;
+    } else {
+        const forecastIdx = index - historical.length;
+        point = forecast[forecastIdx];
+        price = point.predicted_close;
+        date = point.date;
+    }
+
+    const x = padding.left + (index / (totalPoints - 1)) * chartWidth;
+    const y = padding.top + ((adjustedMax - price) / priceRange) * chartHeight;
+
+    // Crosshair lines
+    ctx.strokeStyle = colors.crosshair;
+    ctx.lineWidth = 1;
+    ctx.setLineDash([4, 4]);
+
+    // Vertical line
+    ctx.beginPath();
+    ctx.moveTo(x, padding.top);
+    ctx.lineTo(x, height - padding.bottom);
+    ctx.stroke();
+
+    // Horizontal line
+    ctx.beginPath();
+    ctx.moveTo(padding.left, y);
+    ctx.lineTo(width - padding.right, y);
+    ctx.stroke();
+    ctx.setLineDash([]);
+
+    // Point dot
+    ctx.beginPath();
+    ctx.fillStyle = isHistorical ? colors.line : colors.positive;
+    ctx.arc(x, y, 5, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.strokeStyle = colors.tooltipBg;
+    ctx.lineWidth = 2;
+    ctx.stroke();
+
+    // Tooltip
+    drawForecastTooltip(x, y, point, isHistorical, width, height, padding, colors);
+}
+
+function drawForecastTooltip(x, y, point, isHistorical, width, height, padding, colors) {
+    const ctx = forecastChartState.ctx;
+
+    const date = new Date(point.date);
+    const dateStr = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+
+    const price = isHistorical ? point.close : point.predicted_close;
+    const tooltipWidth = isHistorical ? 140 : 155;
+    const tooltipHeight = isHistorical ? 52 : 72;
+    let tooltipX = x + 12;
+    let tooltipY = y - tooltipHeight / 2;
+
+    // Keep tooltip in bounds
+    if (tooltipX + tooltipWidth > width - padding.right) {
+        tooltipX = x - tooltipWidth - 12;
+    }
+    if (tooltipY < padding.top) {
+        tooltipY = padding.top;
+    }
+    if (tooltipY + tooltipHeight > height - padding.bottom) {
+        tooltipY = height - padding.bottom - tooltipHeight;
+    }
+
+    // Tooltip background
+    ctx.fillStyle = colors.tooltipBg;
+    ctx.strokeStyle = colors.tooltipBorder;
+    ctx.lineWidth = 1;
+    ctx.beginPath();
+    ctx.roundRect(tooltipX, tooltipY, tooltipWidth, tooltipHeight, 6);
+    ctx.fill();
+    ctx.stroke();
+
+    // Tooltip content
+    ctx.fillStyle = colors.text;
+    ctx.font = '10px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    ctx.textAlign = 'left';
+    ctx.textBaseline = 'top';
+    ctx.fillText(dateStr, tooltipX + 10, tooltipY + 8);
+
+    ctx.fillStyle = colors.textStrong;
+    ctx.font = 'bold 16px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+    ctx.fillText(`$${price.toFixed(2)}`, tooltipX + 10, tooltipY + 24);
+
+    if (!isHistorical) {
+        // Show confidence range for predictions
+        ctx.fillStyle = colors.text;
+        ctx.font = '10px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+        const rangeStr = `Range: $${point.lower_bound.toFixed(2)} - $${point.upper_bound.toFixed(2)}`;
+        ctx.fillText(rangeStr, tooltipX + 10, tooltipY + 48);
+    }
+}
+
+function handleForecastChartMouseMove(e) {
+    const { data, canvas, padding, totalPoints } = forecastChartState;
+    if (!data) return;
+
+    const rect = canvas.getBoundingClientRect();
+    const dpr = window.devicePixelRatio || 1;
+    const width = canvas.width / dpr;
+    const chartWidth = width - padding.left - padding.right;
+    const mouseX = e.clientX - rect.left;
+
+    const relativeX = mouseX - padding.left;
+    const index = Math.round((relativeX / chartWidth) * (totalPoints - 1));
+
+    if (index >= 0 && index < totalPoints && index !== forecastChartState.hoveredIndex) {
+        forecastChartState.hoveredIndex = index;
+        drawForecastChart(data, true);
+    }
+}
+
+function handleForecastChartMouseLeave() {
+    forecastChartState.hoveredIndex = -1;
+    if (forecastChartState.data) {
+        drawForecastChart(forecastChartState.data, true);
+    }
+}
+
+
+
+function resetForecastUI() {
+    document.getElementById('forecastModelStatus').textContent = 'Not trained';
+    document.getElementById('forecastLastUpdated').textContent = '--';
+    forecastState.data = null;
+
+    const canvas = document.getElementById('forecastChart');
+    if (canvas) {
+        const ctx = canvas.getContext('2d');
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+    }
+}

fe/index.html

@@ -0,0 +1,304 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MarketLens</title>
+    <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+    <header class="global-header">
+        <div class="header-content">
+            <h1>MarketLens</h1>
+            <div class="header-actions">
+                <div id="marketStatus" class="market-status">
+                    <span class="status-label">Market:</span>
+                    <span id="marketStatusText" class="status-text">Loading...</span>
+                </div>
+                <button id="themeToggle" class="theme-toggle" aria-label="Toggle dark mode">
+                    <svg class="icon-moon" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M20.354 15.354A9 9 0 018.646 3.646 9.003 9.003 0 0012 21a9.003 9.003 0 008.354-5.646z" />
+                    </svg>
+                    <svg class="icon-sun" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 3v1m0 16v1m9-9h-1M4 12H3m15.364 6.364l-.707-.707M6.343 6.343l-.707-.707m12.728 0l-.707.707M6.343 17.657l-.707.707M16 12a4 4 0 11-8 0 4 4 0 018 0z" />
+                    </svg>
+                </button>
+            </div>
+        </div>
+    </header>
+
+    <div class="app-layout">
+        <main class="main-content">
+            <div class="ticker-selector">
+                <label for="tickerSearch">Select a Stock:</label>
+                <div class="dropdown-container">
+                    <input type="text"
+                           id="tickerSearch"
+                           placeholder="Search ticker or company name..."
+                           autocomplete="off">
+                    <div id="dropdownList" class="dropdown-list hidden"></div>
+                </div>
+            </div>
+
+            <div id="stockData" class="stock-data hidden">
+                <div class="stock-header">
+                    <h2 id="stockTitle"></h2>
+                    <div id="stockPrice" class="stock-price"></div>
+                </div>
+
+                <div class="tabs">
+                    <button class="tab-button active" data-tab="overview">Overview</button>
+                    <button class="tab-button" data-tab="financials">Financials</button>
+                    <button class="tab-button" data-tab="dividends">Dividends</button>
+                    <button class="tab-button" data-tab="splits">Splits</button>
+                    <button class="tab-button" data-tab="news">News</button>
+                    <button class="tab-button" data-tab="sentiment">Sentiment</button>
+                    <button class="tab-button" data-tab="forecast">Forecast <span class="beta-tag">Beta</span></button>
+                </div>
+
+                <div class="tab-content">
+                    <div id="overview" class="tab-pane active">
+                        <div class="chart-section">
+                            <h3>Price Chart</h3>
+                            <div class="chart-controls">
+                                <button class="chart-range-btn active" data-range="1M">1M</button>
+                                <button class="chart-range-btn" data-range="3M">3M</button>
+                                <button class="chart-range-btn" data-range="6M">6M</button>
+                                <button class="chart-range-btn" data-range="1Y">1Y</button>
+                                <button class="chart-range-btn" data-range="5Y">5Y</button>
+                                <div class="chart-controls-spacer"></div>
+                                <div class="chart-view-toggle">
+                                    <button class="chart-view-btn active" data-view="line">Line</button>
+                                    <button class="chart-view-btn" data-view="candle">Candle</button>
+                                </div>
+                            </div>
+                            <div class="chart-canvas-wrapper">
+                                <canvas id="priceChart"></canvas>
+                                <div id="chartLoading" class="chart-loading hidden">
+                                    <div class="spinner"></div>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="metrics-grid">
+                            <div class="metric-card">
+                                <div class="metric-label">Open</div>
+                                <div class="metric-value" id="openPrice">--</div>
+                            </div>
+                            <div class="metric-card">
+                                <div class="metric-label">High</div>
+                                <div class="metric-value" id="highPrice">--</div>
+                            </div>
+                            <div class="metric-card">
+                                <div class="metric-label">Low</div>
+                                <div class="metric-value" id="lowPrice">--</div>
+                            </div>
+                            <div class="metric-card">
+                                <div class="metric-label">Volume</div>
+                                <div class="metric-value" id="volume">--</div>
+                            </div>
+                            <div class="metric-card">
+                                <div class="metric-label">Market Cap</div>
+                                <div class="metric-value" id="marketCap">--</div>
+                            </div>
+                            <div class="metric-card">
+                                <div class="metric-label">P/E Ratio</div>
+                                <div class="metric-value" id="peRatio">--</div>
+                            </div>
+                        </div>
+                        <div class="company-description">
+                            <h3>Company Description</h3>
+                            <p id="companyDesc">--</p>
+                        </div>
+                    </div>
+
+                    <div id="financials" class="tab-pane">
+                        <div id="financialsData">
+                            <p>Loading financial data...</p>
+                        </div>
+                    </div>
+
+                    <div id="dividends" class="tab-pane">
+                        <div id="dividendsContainer">
+                            <p>Loading dividend data...</p>
+                        </div>
+                    </div>
+
+                    <div id="splits" class="tab-pane">
+                        <div id="splitsContainer">
+                            <p>Loading stock split data...</p>
+                        </div>
+                    </div>
+
+                    <div id="news" class="tab-pane">
+                        <div id="newsContainer">
+                            <p>Loading news...</p>
+                        </div>
+                    </div>
+
+                    <div id="sentiment" class="tab-pane">
+                        <div class="sentiment-header">
+                            <div class="sentiment-aggregate">
+                                <div class="sentiment-score-container">
+                                    <div class="sentiment-gauge" id="sentimentGauge">
+                                        <div class="gauge-background"></div>
+                                        <div class="gauge-fill" id="gaugeFill"></div>
+                                        <div class="gauge-needle" id="gaugeNeedle"></div>
+                                        <div class="gauge-center"></div>
+                                    </div>
+                                    <div class="sentiment-label" id="sentimentLabel">--</div>
+                                </div>
+                                <div class="sentiment-stats">
+                                    <div class="stat-item">
+                                        <span class="stat-label">Posts Analyzed</span>
+                                        <span class="stat-value" id="sentimentPostCount">--</span>
+                                    </div>
+                                    <div class="stat-item">
+                                        <span class="stat-label">Last Updated</span>
+                                        <span class="stat-value" id="sentimentLastUpdated">--</span>
+                                    </div>
+                                </div>
+                            </div>
+                            <button class="refresh-btn" id="sentimentRefreshBtn" title="Re-scrape and re-analyze">
+                                <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/></svg>
+                                Refresh
+                            </button>
+                        </div>
+
+                        <div class="sentiment-sources">
+                            <h4>Sources</h4>
+                            <div class="source-breakdown">
+                                <div class="source-item" id="stocktwitsSource">
+                                    <span class="source-icon">📈</span>
+                                    <span class="source-name">Stocktwits</span>
+                                    <span class="source-count">--</span>
+                                </div>
+                                <div class="source-item" id="redditSource">
+                                    <span class="source-icon">👽</span>
+                                    <span class="source-name">Reddit</span>
+                                    <span class="source-count">--</span>
+                                </div>
+                                <div class="source-item" id="twitterSource">
+                                    <span class="source-icon">🐦</span>
+                                    <span class="source-name">Twitter/X</span>
+                                    <span class="source-count">--</span>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="sentiment-posts-section">
+                            <div class="posts-header">
+                                <h4>Recent Posts</h4>
+                                <div class="posts-filter">
+                                    <button class="filter-btn active" data-filter="all">All</button>
+                                    <button class="filter-btn" data-filter="positive">Bullish</button>
+                                    <button class="filter-btn" data-filter="negative">Bearish</button>
+                                </div>
+                            </div>
+                            <div id="sentimentPostsContainer">
+                                <p class="loading-text">Select a stock to analyze sentiment...</p>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div id="forecast" class="tab-pane">
+                        <div class="forecast-header">
+                            <div class="forecast-info">
+                                <h4>Price Forecast</h4>
+                                <p class="forecast-description">
+                                    LSTM neural network prediction based on historical price patterns
+                                </p>
+                            </div>
+                            <div class="forecast-controls">
+                                <div class="forecast-status">
+                                    <div class="status-item">
+                                        <span class="status-label">Model Status</span>
+                                        <span class="status-value" id="forecastModelStatus">Not trained</span>
+                                    </div>
+                                    <div class="status-item">
+                                        <span class="status-label">Last Updated</span>
+                                        <span class="status-value" id="forecastLastUpdated">--</span>
+                                    </div>
+                                </div>
+                                <div class="forecast-actions">
+                                    <button class="refresh-btn" id="forecastRefreshBtn" title="Re-train model and re-predict">
+                                        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/></svg>
+                                        Refresh
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div id="forecastTableContainer"></div>
+
+                        <div class="forecast-chart-section">
+                            <div class="chart-legend">
+                                <span class="legend-item historical">
+                                    <span class="legend-color"></span> Historical
+                                </span>
+                                <span class="legend-item predicted">
+                                    <span class="legend-color"></span> Predicted
+                                </span>
+                                <span class="legend-item confidence">
+                                    <span class="legend-color"></span> Confidence Band
+                                </span>
+                            </div>
+                            <canvas id="forecastChart"></canvas>
+                        </div>
+
+                        <div class="forecast-disclaimer">
+                            <p>
+                                <strong>Disclaimer:</strong> These predictions are generated by a machine learning model
+                                for educational purposes only. Past performance does not guarantee future results.
+                                This is not financial advice.
+                            </p>
+                        </div>
+                    </div>
+                </div>
+
+                <div id="loading" class="loading hidden">
+                    <div class="spinner"></div>
+                </div>
+            </div>
+        </main>
+
+        <!-- Chat Panel -->
+        <aside class="chat-panel" id="chatPanel">
+            <div class="chat-panel-content">
+                <div class="chat-header">
+                    <h3>AI Assistant</h3>
+                    <button id="closeMobileChat" class="close-mobile-chat" aria-label="Close chat">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                            <line x1="18" y1="6" x2="6" y2="18"></line>
+                            <line x1="6" y1="6" x2="18" y2="18"></line>
+                        </svg>
+                    </button>
+                </div>
+
+                <div class="chat-ticker-context">
+                    <span id="chatCurrentTicker">Select a stock to start</span>
+                </div>
+
+                <div id="chatMessages" class="chat-messages">
+                    <!-- Messages populated dynamically -->
+                </div>
+
+                <div class="chat-input-container">
+                    <textarea id="chatInput"
+                              placeholder="Ask about this stock..."
+                              rows="2"></textarea>
+                    <button id="sendChatBtn" class="send-chat-btn">Send</button>
+                </div>
+            </div>
+        </aside>
+    </div>
+
+    <!-- Mobile Chat Toggle (visible on small screens only) -->
+    <button id="mobileChatToggle" class="mobile-chat-toggle" aria-label="Toggle chat">
+        <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+        </svg>
+    </button>
+
+    <script src="app.js"></script>
+</body>
+</html>

fe/styles.css

@@ -0,0 +1,1942 @@
+/* ============================================
+   MarketLens - Design System
+   Direction: Data-dense, professional, terminal-inspired
+   Base unit: 16px | Depth: Subtle shadows
+   ============================================ */
+
+/* CSS Custom Properties */
+:root {
+    /* Neutrals - Slate palette */
+    --color-bg: #f8fafc;
+    --color-bg-elevated: #ffffff;
+    --color-bg-subtle: #f1f5f9;
+    --color-bg-muted: #e2e8f0;
+
+    --color-border: #e2e8f0;
+    --color-border-subtle: #f1f5f9;
+
+    --color-text: #0f172a;
+    --color-text-secondary: #475569;
+    --color-text-muted: #94a3b8;
+
+    /* Accent - Indigo */
+    --color-accent: #4f46e5;
+    --color-accent-hover: #4338ca;
+    --color-accent-subtle: #eef2ff;
+
+    /* Semantic */
+    --color-positive: #059669;
+    --color-positive-bg: #ecfdf5;
+    --color-negative: #dc2626;
+    --color-negative-bg: #fef2f2;
+    --color-neutral-sentiment: #94a3b8;
+    --color-neutral-sentiment-bg: rgba(148, 163, 184, 0.15);
+
+    /* Spacing */
+    --space-1: 4px;
+    --space-2: 8px;
+    --space-3: 12px;
+    --space-4: 16px;
+    --space-5: 20px;
+    --space-6: 24px;
+    --space-8: 32px;
+    --space-10: 40px;
+    --space-12: 48px;
+
+    /* Typography */
+    --font-sans: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Inter', system-ui, sans-serif;
+    --font-mono: 'SF Mono', 'Fira Code', 'Consolas', monospace;
+
+    --text-2xs: 0.625rem;
+    --text-xs: 0.75rem;
+    --text-sm: 0.875rem;
+    --text-base: 1rem;
+    --text-lg: 1.125rem;
+    --text-xl: 1.25rem;
+    --text-2xl: 1.5rem;
+    --text-3xl: 2rem;
+
+    /* Line heights */
+    --line-height-dense: 1.3;
+    --line-height-tight: 1.15;
+
+    /* Shadows */
+    --shadow-sm: 0 1px 2px rgba(15, 23, 42, 0.04);
+    --shadow-md: 0 2px 8px rgba(15, 23, 42, 0.06);
+    --shadow-lg: 0 4px 16px rgba(15, 23, 42, 0.08);
+
+    /* Radius */
+    --radius-sm: 4px;
+    --radius-md: 6px;
+    --radius-lg: 8px;
+    --radius-xl: 12px;
+
+    /* Layout */
+    --header-height: 60px;
+    --chat-width: 340px;
+}
+
+/* Dark Mode */
+[data-theme="dark"] {
+    --color-bg: #0f172a;
+    --color-bg-elevated: #1e293b;
+    --color-bg-subtle: #1e293b;
+    --color-bg-muted: #334155;
+
+    --color-border: #334155;
+    --color-border-subtle: #1e293b;
+
+    --color-text: #f1f5f9;
+    --color-text-secondary: #cbd5e1;
+    --color-text-muted: #64748b;
+
+    --color-accent: #818cf8;
+    --color-accent-hover: #a5b4fc;
+    --color-accent-subtle: rgba(129, 140, 248, 0.15);
+
+    --color-positive: #34d399;
+    --color-positive-bg: rgba(52, 211, 153, 0.15);
+    --color-negative: #f87171;
+    --color-negative-bg: rgba(248, 113, 113, 0.15);
+
+    --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.2);
+    --shadow-md: 0 2px 8px rgba(0, 0, 0, 0.25);
+    --shadow-lg: 0 4px 16px rgba(0, 0, 0, 0.3);
+}
+
+/* Reset & Base */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+html, body {
+    height: 100%;
+}
+
+body {
+    font-family: var(--font-sans);
+    background-color: var(--color-bg);
+    color: var(--color-text);
+    line-height: 1.5;
+    font-size: var(--text-sm);
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    overflow: hidden;
+}
+
+/* ============================================
+   App Layout - Persistent Chat Panel
+   ============================================ */
+
+.global-header {
+    height: var(--header-height);
+    background: var(--color-bg-elevated);
+    border-bottom: 1px solid var(--color-border);
+    padding: 0 var(--space-5);
+    display: flex;
+    align-items: center;
+    box-shadow: var(--shadow-sm);
+    position: relative;
+    z-index: 100;
+}
+
+.global-header .header-content {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    width: 100%;
+    max-width: 1600px;
+    margin: 0 auto;
+}
+
+.global-header h1 {
+    font-size: var(--text-lg);
+    font-weight: 700;
+    color: var(--color-text);
+    letter-spacing: -0.03em;
+}
+
+.header-actions {
+    display: flex;
+    align-items: center;
+    gap: var(--space-4);
+}
+
+.market-status {
+    display: flex;
+    align-items: center;
+    gap: var(--space-2);
+    font-size: var(--text-xs);
+}
+
+.status-label {
+    color: var(--color-text-muted);
+    font-weight: 500;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.status-text {
+    padding: var(--space-1) var(--space-2);
+    border-radius: var(--radius-sm);
+    font-weight: 600;
+    font-size: 10px;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.status-open {
+    background: var(--color-positive-bg);
+    color: var(--color-positive);
+}
+
+.status-closed {
+    background: var(--color-negative-bg);
+    color: var(--color-negative);
+}
+
+.theme-toggle {
+    background: var(--color-bg-subtle);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-sm);
+    padding: var(--space-2);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 32px;
+    height: 32px;
+    transition: background 0.15s, border-color 0.15s;
+}
+
+.theme-toggle:hover {
+    background: var(--color-bg-muted);
+}
+
+.theme-toggle:active {
+    transform: scale(0.96);
+}
+
+.theme-toggle svg {
+    width: 16px;
+    height: 16px;
+    color: var(--color-text-secondary);
+}
+
+.theme-toggle .icon-moon {
+    display: block;
+}
+
+.theme-toggle .icon-sun {
+    display: none;
+}
+
+[data-theme="dark"] .theme-toggle .icon-moon {
+    display: none;
+}
+
+[data-theme="dark"] .theme-toggle .icon-sun {
+    display: block;
+}
+
+/* App Layout Grid */
+.app-layout {
+    display: grid;
+    grid-template-columns: 1fr var(--chat-width);
+    height: calc(100vh - var(--header-height));
+}
+
+/* Main Content Area */
+.main-content {
+    overflow-y: auto;
+    padding: var(--space-4) var(--space-5);
+    background: var(--color-bg);
+    scrollbar-width: thin;
+    scrollbar-color: var(--color-border) transparent;
+}
+
+.main-content::-webkit-scrollbar {
+    width: 6px;
+}
+
+.main-content::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+.main-content::-webkit-scrollbar-thumb {
+    background: var(--color-border);
+    border-radius: 3px;
+}
+
+.main-content::-webkit-scrollbar-thumb:hover {
+    background: var(--color-text-muted);
+}
+
+/* ============================================
+   Chat Panel - Persistent Right Side
+   ============================================ */
+
+.chat-panel {
+    background: var(--color-bg-elevated);
+    border-left: 1px solid var(--color-border);
+    display: flex;
+    flex-direction: column;
+    position: relative;
+    overflow: hidden;
+}
+
+.chat-panel-content {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    overflow: hidden;
+    transition: opacity 0.2s;
+}
+
+.chat-header {
+    padding: var(--space-3) var(--space-4);
+    background: var(--color-bg-elevated);
+    border-bottom: 1px solid var(--color-border);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.chat-header h3 {
+    margin: 0;
+    font-size: var(--text-sm);
+    font-weight: 600;
+    color: var(--color-text);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.close-mobile-chat {
+    display: none;
+    background: none;
+    border: none;
+    color: var(--color-text-muted);
+    cursor: pointer;
+    padding: var(--space-1);
+    border-radius: var(--radius-sm);
+    transition: background 0.15s, color 0.15s;
+}
+
+.close-mobile-chat:hover {
+    background: var(--color-bg-subtle);
+    color: var(--color-text);
+}
+
+.chat-ticker-context {
+    padding: var(--space-2) var(--space-4);
+    background: var(--color-bg-subtle);
+    border-bottom: 1px solid var(--color-border-subtle);
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--color-text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.chat-messages {
+    flex: 1;
+    overflow-y: auto;
+    padding: var(--space-4);
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-3);
+    background: var(--color-bg);
+}
+
+.message {
+    max-width: 90%;
+    padding: var(--space-2) var(--space-3);
+    border-radius: var(--radius-md);
+    line-height: var(--line-height-dense);
+    word-wrap: break-word;
+    font-size: var(--text-sm);
+    animation: messageIn 0.2s ease-out;
+}
+
+@keyframes messageIn {
+    from {
+        opacity: 0;
+        transform: translateY(6px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.message.user {
+    align-self: flex-end;
+    background: var(--color-accent);
+    color: white;
+    border-bottom-right-radius: var(--radius-sm);
+}
+
+.message.assistant {
+    align-self: flex-start;
+    background: var(--color-bg-elevated);
+    color: var(--color-text);
+    border: 1px solid var(--color-border);
+    border-bottom-left-radius: var(--radius-sm);
+}
+
+.message.error {
+    align-self: flex-start;
+    background: var(--color-negative-bg);
+    color: var(--color-negative);
+    border: 1px solid var(--color-negative);
+}
+
+.message.loading {
+    align-self: flex-start;
+    background: var(--color-bg-elevated);
+    border: 1px solid var(--color-border);
+    padding: var(--space-3);
+}
+
+.typing-indicator {
+    display: flex;
+    gap: 4px;
+    align-items: center;
+}
+
+.typing-indicator span {
+    width: 5px;
+    height: 5px;
+    background: var(--color-text-muted);
+    border-radius: 50%;
+    animation: typing 1.2s infinite;
+}
+
+.typing-indicator span:nth-child(2) {
+    animation-delay: 0.15s;
+}
+
+.typing-indicator span:nth-child(3) {
+    animation-delay: 0.3s;
+}
+
+@keyframes typing {
+    0%, 60%, 100% {
+        transform: translateY(0);
+        opacity: 0.4;
+    }
+    30% {
+        transform: translateY(-4px);
+        opacity: 1;
+    }
+}
+
+/* Agent tool call status indicators */
+.message.tool-status {
+    align-self: flex-start;
+    background: transparent;
+    padding: var(--space-1) var(--space-2);
+    max-width: 100%;
+    border: none;
+}
+
+.tool-status-item {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 2px 0;
+    font-size: var(--text-xs);
+    color: var(--color-text-muted);
+}
+
+.tool-status-item.complete {
+    color: var(--color-positive);
+}
+
+.tool-status-item.error {
+    color: var(--color-negative);
+}
+
+.tool-status-item.calling {
+    color: var(--color-accent);
+}
+
+.tool-spinner {
+    display: inline-block;
+    width: 10px;
+    height: 10px;
+    border: 2px solid var(--color-border);
+    border-top-color: var(--color-accent);
+    border-radius: 50%;
+    animation: tool-spin 0.6s linear infinite;
+}
+
+@keyframes tool-spin {
+    to { transform: rotate(360deg); }
+}
+
+.tool-status-complete {
+    opacity: 0.5;
+    max-height: 80px;
+    overflow: hidden;
+    transition: opacity 0.3s ease, max-height 0.3s ease;
+}
+
+.chat-input-container {
+    padding: var(--space-3);
+    border-top: 1px solid var(--color-border);
+    background: var(--color-bg-elevated);
+    display: flex;
+    gap: var(--space-2);
+}
+
+#chatInput {
+    flex: 1;
+    padding: var(--space-2) var(--space-3);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-sm);
+    font-family: var(--font-sans);
+    font-size: var(--text-sm);
+    resize: none;
+    transition: border-color 0.15s, box-shadow 0.15s;
+    background: var(--color-bg-elevated);
+    color: var(--color-text);
+}
+
+#chatInput::placeholder {
+    color: var(--color-text-muted);
+}
+
+#chatInput:focus {
+    outline: none;
+    border-color: var(--color-accent);
+    box-shadow: 0 0 0 2px var(--color-accent-subtle);
+}
+
+.send-chat-btn {
+    background: var(--color-accent);
+    color: white;
+    border: none;
+    padding: var(--space-2) var(--space-4);
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    font-weight: 600;
+    font-size: var(--text-xs);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    transition: background 0.15s, transform 0.1s;
+    font-family: var(--font-sans);
+}
+
+.send-chat-btn:hover {
+    background: var(--color-accent-hover);
+}
+
+.send-chat-btn:active {
+    transform: scale(0.96);
+}
+
+.send-chat-btn:disabled {
+    background: var(--color-bg-muted);
+    color: var(--color-text-muted);
+    cursor: not-allowed;
+}
+
+/* ============================================
+   Ticker Selector - Compact
+   ============================================ */
+
+.ticker-selector {
+    background: var(--color-bg-elevated);
+    border: 1px solid var(--color-border);
+    padding: var(--space-3) var(--space-4);
+    border-radius: var(--radius-md);
+    margin-bottom: var(--space-4);
+    box-shadow: var(--shadow-sm);
+}
+
+.ticker-selector label {
+    display: block;
+    margin-bottom: var(--space-1);
+    font-weight: 600;
+    font-size: 10px;
+    color: var(--color-text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+}
+
+.dropdown-container {
+    position: relative;
+}
+
+#tickerSearch {
+    width: 100%;
+    padding: var(--space-2) var(--space-3);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-sm);
+    font-size: var(--text-sm);
+    font-family: var(--font-sans);
+    background: var(--color-bg-elevated);
+    color: var(--color-text);
+    transition: border-color 0.15s, box-shadow 0.15s;
+}
+
+#tickerSearch::placeholder {
+    color: var(--color-text-muted);
+}
+
+#tickerSearch:focus {
+    outline: none;
+    border-color: var(--color-accent);
+    box-shadow: 0 0 0 2px var(--color-accent-subtle);
+}
+
+.dropdown-list {
+    position: absolute;
+    top: calc(100% + 4px);
+    left: 0;
+    right: 0;
+    max-height: 320px;
+    overflow-y: auto;
+    background: var(--color-bg-elevated);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-md);
+    box-shadow: var(--shadow-lg);
+    z-index: 1000;
+}
+
+.dropdown-section-header {
+    padding: var(--space-1) var(--space-3);
+    font-size: 10px;
+    font-weight: 700;
+    color: var(--color-text-muted);
+    background: var(--color-bg-subtle);
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    border-bottom: 1px solid var(--color-border-subtle);
+    position: sticky;
+    top: 0;
+}
+
+.dropdown-item {
+    padding: var(--space-2) var(--space-3);
+    cursor: pointer;
+    transition: background 0.1s;
+    border-bottom: 1px solid var(--color-border-subtle);
+    font-size: var(--text-sm);
+}
+
+.dropdown-item:hover,
+.dropdown-item.highlighted {
+    background: var(--color-bg-subtle);
+}
+
+.dropdown-item:last-child {
+    border-bottom: none;
+}
+
+.dropdown-no-results {
+    padding: var(--space-4);
+    text-align: center;
+    color: var(--color-text-muted);
+    font-size: var(--text-sm);
+}
+
+/* ============================================
+   Stock Data Card - Compact
+   ============================================ */
+
+.stock-data {
+    background: var(--color-bg-elevated);
+    border: 1px solid var(--color-border);
+    padding: var(--space-4);
+    border-radius: var(--radius-md);
+    box-shadow: var(--shadow-sm);
+}
+
+.stock-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: baseline;
+    margin-bottom: var(--space-4);
+    padding-bottom: var(--space-3);
+    border-bottom: 1px solid var(--color-border);
+}
+
+.stock-header h2 {
+    font-size: var(--text-xl);
+    font-weight: 700;
+    color: var(--color-text);
+    letter-spacing: -0.025em;
+}
+
+.stock-price {
+    font-size: var(--text-2xl);
+    font-weight: 700;
+    font-family: var(--font-mono);
+    letter-spacing: -0.02em;
+}
+
+.stock-price.positive {
+    color: var(--color-positive);
+}
+
+.stock-price.negative {
+    color: var(--color-negative);
+}
+
+/* ============================================
+   Tabs - Terminal Style
+   ============================================ */
+
+.tabs {
+    display: flex;
+    gap: 0;
+    margin-bottom: var(--space-4);
+    border-bottom: 1px solid var(--color-border);
+    background: var(--color-bg-subtle);
+    border-radius: var(--radius-sm) var(--radius-sm) 0 0;
+    overflow-x: auto;
+    scrollbar-width: none;
+    -ms-overflow-style: none;
+}
+
+.tabs::-webkit-scrollbar {
+    display: none;
+}
+
+.tab-button {
+    padding: var(--space-2) var(--space-4);
+    background: none;
+    border: none;
+    font-size: 11px;
+    font-weight: 600;
+    cursor: pointer;
+    color: var(--color-text-muted);
+    transition: color 0.15s, background 0.15s;
+    border-bottom: 2px solid transparent;
+    margin-bottom: -1px;
+    white-space: nowrap;
+    font-family: var(--font-sans);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.tab-button:hover {
+    color: var(--color-text-secondary);
+    background: var(--color-bg-muted);
+}
+
+.tab-button.active {
+    color: var(--color-accent);
+    background: var(--color-bg-elevated);
+    border-bottom-color: var(--color-accent);
+}
+
+.beta-tag {
+    display: inline-block;
+    padding: 1px 4px;
+    margin-left: var(--space-1);
+    font-size: 9px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    background: var(--color-accent-subtle);
+    color: var(--color-accent);
+    border-radius: 2px;
+    vertical-align: middle;
+}
+
+.tab-content {
+    position: relative;
+}
+
+.tab-pane {
+    display: none;
+    opacity: 0;
+    transform: translateY(6px);
+}
+
+.tab-pane.active {
+    display: block;
+    animation: fadeInUp 0.2s ease forwards;
+}
+
+@keyframes fadeInUp {
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+/* ============================================
+   Metrics Grid - Dense
+   ============================================ */
+
+.metrics-grid {
+    display: grid;
+    grid-template-columns: repeat(6, 1fr);
+    gap: var(--space-2);
+    margin-bottom: var(--space-4);
+}
+
+.metric-card {
+    background: var(--color-bg-subtle);
+    padding: var(--space-2) var(--space-3);
+    border-radius: var(--radius-sm);
+    border: 1px solid var(--color-border-subtle);
+}
+
+.metric-label {
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--color-text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    margin-bottom: 2px;
+}
+
+.metric-value {
+    font-size: var(--text-base);
+    font-weight: 600;
+    color: var(--color-text);
+    font-family: var(--font-mono);
+    line-height: var(--line-height-tight);
+}
+
+/* ============================================
+   Chart Section - Compact
+   ============================================ */
+
+.chart-section {
+    margin-bottom: var(--space-4);
+    padding: var(--space-3);
+    background: var(--color-bg-subtle);
+    border-radius: var(--radius-md);
+    border: 1px solid var(--color-border-subtle);
+}
+
+.chart-section h3 {
+    font-size: 10px;
+    font-weight: 700;
+    color: var(--color-text-muted);
+    margin-bottom: var(--space-3);
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+}
+
+.chart-controls {
+    display: flex;
+    gap: var(--space-1);
+    margin-bottom: var(--space-3);
+}
+
+.chart-range-btn {
+    padding: var(--space-1) var(--space-2);
+    background: var(--color-bg-elevated);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--color-text-muted);
+    transition: all 0.15s;
+    font-family: var(--font-mono);
+}
+
+.chart-range-btn:hover {
+    background: var(--color-bg-muted);
+    color: var(--color-text-secondary);
+}
+
+.chart-range-btn:active {
+    transform: scale(0.96);
+}
+
+.chart-range-btn.active {
+    background: var(--color-accent);
+    color: white;
+    border-color: var(--color-accent);
+}
+
+.chart-controls-spacer {
+    flex: 1;
+}
+
+.chart-view-toggle {
+    display: flex;
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-sm);
+    overflow: hidden;
+}
+
+.chart-view-btn {
+    padding: var(--space-1) var(--space-2);
+    background: var(--color-bg-elevated);
+    border: none;
+    border-right: 1px solid var(--color-border);
+    cursor: pointer;
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--color-text-muted);
+    transition: all 0.15s;
+    font-family: var(--font-sans);
+}
+
+.chart-view-btn:last-child {
+    border-right: none;
+}
+
+.chart-view-btn:hover {
+    background: var(--color-bg-muted);
+}
+
+.chart-view-btn:active {
+    transform: scale(0.96);
+}
+
+.chart-view-btn.active {
+    background: var(--color-accent);
+    color: white;
+}
+
+.chart-canvas-wrapper {
+    position: relative;
+}
+
+.chart-loading {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+}
+
+#priceChart {
+    width: 100%;
+    height: 280px;
+    background: var(--color-bg-elevated);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-sm);
+    cursor: crosshair;
+}
+
+/* ============================================
+   Company Description - Compact
+   ============================================ */
+
+.company-description {
+    padding: var(--space-3);
+    background: var(--color-bg-subtle);
+    border-radius: var(--radius-md);
+    border: 1px solid var(--color-border-subtle);
+}
+
+.company-description h3 {
+    font-size: 10px;
+    font-weight: 700;
+    color: var(--color-text-muted);
+    margin-bottom: var(--space-2);
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+}
+
+.company-description p {
+    font-size: var(--text-sm);
+    line-height: 1.6;
+    color: var(--color-text-secondary);
+}
+
+/* ============================================
+   Financials - Dense
+   ============================================ */
+
+#financialsData {
+    padding: var(--space-2);
+}
+
+.financial-period {
+    margin-bottom: var(--space-4);
+    padding: var(--space-3);
+    background: var(--color-bg-subtle);
+    border-radius: var(--radius-md);
+    border: 1px solid var(--color-border-subtle);
+}
+
+.financial-period h4 {
+    margin-bottom: var(--space-3);
+    color: var(--color-text);
+    font-size: 10px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+}
+
+.financial-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+    gap: var(--space-2);
+}
+
+.financial-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: var(--space-2) var(--space-3);
+    background: var(--color-bg-elevated);
+    border-radius: var(--radius-sm);
+    border: 1px solid var(--color-border-subtle);
+}
+
+.financial-item-label {
+    color: var(--color-text-secondary);
+    font-size: var(--text-xs);
+}
+
+.financial-item-value {
+    font-weight: 600;
+    color: var(--color-text);
+    font-family: var(--font-mono);
+    font-size: var(--text-xs);
+}
+
+/* ============================================
+   News - Dense
+   ============================================ */
+
+#newsContainer {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-3);
+}
+
+.news-article {
+    padding: var(--space-3);
+    background: var(--color-bg-subtle);
+    border-radius: var(--radius-md);
+    border: 1px solid var(--color-border-subtle);
+    transition: border-color 0.15s;
+}
+
+.news-article:hover {
+    border-color: var(--color-border);
+}
+
+.news-article h4 {
+    margin-bottom: var(--space-1);
+    font-size: var(--text-sm);
+    font-weight: 600;
+    line-height: var(--line-height-dense);
+}
+
+.news-article h4 a {
+    color: var(--color-text);
+    text-decoration: none;
+    transition: color 0.15s;
+}
+
+.news-article h4 a:hover {
+    color: var(--color-accent);
+}
+
+.news-meta {
+    font-size: 10px;
+    color: var(--color-text-muted);
+    margin-bottom: var(--space-2);
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+}
+
+.news-description {
+    color: var(--color-text-secondary);
+    font-size: var(--text-xs);
+    line-height: 1.5;
+}
+
+/* ============================================
+   Data Tables - Dense with Sticky Headers
+   ============================================ */
+
+.data-table-container {
+    max-height: 400px;
+    overflow-y: auto;
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-md);
+}
+
+.data-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: var(--text-xs);
+}
+
+.data-table thead {
+    position: sticky;
+    top: 0;
+    z-index: 10;
+    background: var(--color-bg-subtle);
+}
+
+.data-table th {
+    padding: var(--space-2) var(--space-3);
+    text-align: left;
+    font-weight: 700;
+    color: var(--color-text-muted);
+    font-size: 10px;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    border-bottom: 2px solid var(--color-border);
+    white-space: nowrap;
+}
+
+.data-table td {
+    padding: var(--space-2) var(--space-3);
+    border-bottom: 1px solid var(--color-border-subtle);
+    color: var(--color-text);
+    font-family: var(--font-mono);
+    font-size: 12px;
+}
+
+.data-table td[data-type="number"] {
+    text-align: right;
+}
+
+.data-table tbody tr:nth-child(even) {
+    background: var(--color-bg-subtle);
+}
+
+.data-table tbody tr:hover {
+    background: var(--color-accent-subtle);
+}
+
+.data-table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+/* ============================================
+   Loading States & Skeletons
+   ============================================ */
+
+.loading {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+}
+
+.spinner {
+    width: 24px;
+    height: 24px;
+    border: 2px solid var(--color-border);
+    border-top-color: var(--color-accent);
+    border-radius: 50%;
+    animation: spin 0.7s linear infinite;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+.hidden {
+    display: none;
+}
+
+/* Skeleton Loading */
+.skeleton {
+    background: linear-gradient(
+        90deg,
+        var(--color-bg-subtle) 25%,
+        var(--color-bg-muted) 50%,
+        var(--color-bg-subtle) 75%
+    );
+    background-size: 200% 100%;
+    animation: skeleton-loading 1.5s infinite;
+    border-radius: var(--radius-sm);
+}
+
+@keyframes skeleton-loading {
+    0% { background-position: 200% 0; }
+    100% { background-position: -200% 0; }
+}
+
+.skeleton-metric {
+    height: 48px;
+}
+
+.skeleton-chart {
+    height: 280px;
+}
+
+.skeleton-text {
+    height: 14px;
+    margin-bottom: 8px;
+}
+
+.skeleton-text:last-child {
+    width: 60%;
+}
+
+.skeleton-text-sm {
+    height: 12px;
+    margin-bottom: 6px;
+}
+
+/* ============================================
+   Empty States
+   ============================================ */
+
+.empty-state {
+    text-align: center;
+    padding: var(--space-8) var(--space-4);
+    color: var(--color-text-muted);
+}
+
+.empty-state-icon {
+    width: 40px;
+    height: 40px;
+    margin: 0 auto var(--space-3);
+    opacity: 0.5;
+    color: var(--color-text-muted);
+}
+
+.empty-state-title {
+    font-size: var(--text-sm);
+    font-weight: 600;
+    color: var(--color-text-secondary);
+    margin-bottom: var(--space-1);
+}
+
+.empty-state-description {
+    font-size: var(--text-xs);
+    max-width: 240px;
+    margin: 0 auto;
+    line-height: 1.5;
+}
+
+/* ============================================
+   Micro-animations
+   ============================================ */
+
+/* Button press feedback */
+button:active:not(:disabled) {
+    transform: scale(0.98);
+}
+
+/* Data update flash */
+.data-updated {
+    animation: dataFlash 0.3s ease;
+}
+
+@keyframes dataFlash {
+    0%, 100% { background: transparent; }
+    50% { background: var(--color-accent-subtle); }
+}
+
+/* Focus visible states */
+:focus-visible {
+    outline: 2px solid var(--color-accent);
+    outline-offset: 2px;
+}
+
+/* ============================================
+   Sentiment Analysis Tab
+   ============================================ */
+
+.sentiment-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    gap: var(--space-4);
+    margin-bottom: var(--space-4);
+    padding: var(--space-3);
+    background: var(--color-bg-elevated);
+    border-radius: var(--radius-md);
+    border: 1px solid var(--color-border);
+}
+
+.sentiment-aggregate {
+    display: flex;
+    gap: var(--space-6);
+    align-items: center;
+}
+
+.sentiment-score-container {
+    text-align: center;
+}
+
+/* Sentiment Gauge */
+.sentiment-gauge {
+    width: 120px;
+    height: 60px;
+    position: relative;
+    overflow: hidden;
+    margin-bottom: var(--space-2);
+}
+
+.gauge-background {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    width: 120px;
+    height: 60px;
+    border-radius: 60px 60px 0 0;
+    background: linear-gradient(90deg,
+        var(--color-negative) 0%,
+        var(--color-negative) 20%,
+        var(--color-neutral-sentiment) 40%,
+        var(--color-neutral-sentiment) 60%,
+        var(--color-positive) 80%,
+        var(--color-positive) 100%
+    );
+    opacity: 0.15;
+}
+
+.gauge-fill {
+    position: absolute;
+    bottom: 0;
+    left: 50%;
+    width: 3px;
+    height: 50px;
+    background: var(--color-text-muted);
+    transform-origin: bottom center;
+    transform: rotate(0deg);
+    transition: transform 0.5s ease-out, background 0.3s;
+    border-radius: 2px;
+    z-index: 2;
+}
+
+.gauge-fill.bullish {
+    background: var(--color-positive);
+}
+
+.gauge-fill.bearish {
+    background: var(--color-negative);
+}
+
+.gauge-fill.neutral {
+    background: var(--color-neutral-sentiment);
+}
+
+.gauge-needle {
+    position: absolute;
+    bottom: 0;
+    left: 50%;
+    width: 2px;
+    height: 45px;
+    background: var(--color-text);
+    transform-origin: bottom center;
+    transform: rotate(0deg);
+    transition: transform 0.6s cubic-bezier(0.4, 0, 0.2, 1);
+    border-radius: 2px;
+    z-index: 3;
+    margin-left: -1px;
+}
+
+.gauge-center {
+    position: absolute;
+    bottom: -6px;
+    left: 50%;
+    transform: translateX(-50%);
+    width: 12px;
+    height: 12px;
+    background: var(--color-bg-elevated);
+    border: 2px solid var(--color-text);
+    border-radius: 50%;
+    z-index: 4;
+}
+
+.sentiment-label {
+    font-size: var(--text-base);
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.sentiment-label.bullish {
+    color: var(--color-positive);
+}
+
+.sentiment-label.bearish {
+    color: var(--color-negative);
+}
+
+.sentiment-label.neutral {
+    color: var(--color-neutral-sentiment);
+}
+
+.sentiment-stats {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-3);
+}
+
+.sentiment-stats .stat-item {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+}
+
+.sentiment-stats .stat-label {
+    font-size: 10px;
+    color: var(--color-text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.sentiment-stats .stat-value {
+    font-size: var(--text-base);
+    font-weight: 600;
+    color: var(--color-text);
+    font-family: var(--font-mono);
+}
+
+.refresh-btn {
+    display: flex;
+    align-items: center;
+    gap: var(--space-2);
+    padding: var(--space-2) var(--space-3);
+    background: var(--color-bg-subtle);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--color-text-secondary);
+    transition: all 0.15s;
+    font-family: var(--font-sans);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.refresh-btn:hover {
+    background: var(--color-bg-muted);
+}
+
+.refresh-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.refresh-btn.loading svg {
+    animation: spin 1s linear infinite;
+}
+
+/* Source Breakdown */
+.sentiment-sources {
+    margin-bottom: var(--space-4);
+}
+
+.sentiment-sources h4 {
+    font-size: 10px;
+    font-weight: 700;
+    color: var(--color-text-muted);
+    margin-bottom: var(--space-2);
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+}
+
+.source-breakdown {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: var(--space-2);
+}
+
+.source-item {
+    display: flex;
+    align-items: center;
+    gap: var(--space-2);
+    padding: var(--space-2) var(--space-3);
+    background: var(--color-bg-elevated);
+    border-radius: var(--radius-sm);
+    border: 1px solid var(--color-border);
+}
+
+.source-icon {
+    font-size: var(--text-sm);
+}
+
+.source-name {
+    font-size: var(--text-xs);
+    color: var(--color-text-secondary);
+    flex: 1;
+}
+
+.source-count {
+    font-size: var(--text-sm);
+    font-weight: 600;
+    color: var(--color-text);
+    font-family: var(--font-mono);
+}
+
+/* Sentiment Posts Section */
+.sentiment-posts-section {
+    background: var(--color-bg-elevated);
+    border-radius: var(--radius-md);
+    border: 1px solid var(--color-border);
+    padding: var(--space-3);
+}
+
+.posts-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--space-3);
+}
+
+.posts-header h4 {
+    font-size: 10px;
+    font-weight: 700;
+    color: var(--color-text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+}
+
+.posts-filter {
+    display: flex;
+    gap: var(--space-1);
+}
+
+.filter-btn {
+    padding: var(--space-1) var(--space-2);
+    background: var(--color-bg-subtle);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    font-size: 10px;
+    font-weight: 600;
+    color: var(--color-text-muted);
+    transition: all 0.15s;
+    font-family: var(--font-sans);
+}
+
+.filter-btn:hover {
+    background: var(--color-bg-muted);
+}
+
+.filter-btn.active {
+    background: var(--color-accent);
+    color: white;
+    border-color: var(--color-accent);
+}
+
+#sentimentPostsContainer {
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+.sentiment-post {
+    padding: var(--space-3);
+    background: var(--color-bg-subtle);
+    border-radius: var(--radius-sm);
+    border-left: 3px solid var(--color-border);
+    margin-bottom: var(--space-2);
+    transition: border-color 0.15s;
+}
+
+.sentiment-post:last-child {
+    margin-bottom: 0;
+}
+
+.sentiment-post.positive {
+    border-left-color: var(--color-positive);
+}
+
+.sentiment-post.negative {
+    border-left-color: var(--color-negative);
+}
+
+.sentiment-post.neutral {
+    border-left-color: var(--color-neutral-sentiment);
+}
+
+.sentiment-post .post-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--space-1);
+}
+
+.post-platform {
+    font-size: 10px;
+    font-weight: 700;
+    color: var(--color-text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.02em;
+}
+
+.post-sentiment {
+    font-size: 10px;
+    font-weight: 600;
+    padding: 2px var(--space-2);
+    border-radius: 2px;
+}
+
+.post-sentiment.positive {
+    background: var(--color-positive-bg);
+    color: var(--color-positive);
+}
+
+.post-sentiment.negative {
+    background: var(--color-negative-bg);
+    color: var(--color-negative);
+}
+
+.post-sentiment.neutral {
+    background: var(--color-neutral-sentiment-bg);
+    color: var(--color-neutral-sentiment);
+}
+
+.post-content {
+    font-size: var(--text-xs);
+    line-height: 1.5;
+    color: var(--color-text);
+    margin-bottom: var(--space-2);
+    word-break: break-word;
+}
+
+.post-meta {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--space-2);
+    font-size: 10px;
+    color: var(--color-text-muted);
+}
+
+.post-link {
+    display: inline-block;
+    margin-top: var(--space-1);
+    font-size: 10px;
+    color: var(--color-accent);
+    text-decoration: none;
+}
+
+.post-link:hover {
+    text-decoration: underline;
+}
+
+.loading-text,
+.error-text,
+.no-data-text {
+    text-align: center;
+    padding: var(--space-6);
+    color: var(--color-text-muted);
+    font-size: var(--text-sm);
+}
+
+.error-text {
+    color: var(--color-negative);
+}
+
+/* ============================================
+   Forecast Tab
+   ============================================ */
+
+.forecast-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    gap: var(--space-4);
+    margin-bottom: var(--space-4);
+    padding: var(--space-3);
+    background: var(--color-bg-elevated);
+    border-radius: var(--radius-md);
+    border: 1px solid var(--color-border);
+    flex-wrap: wrap;
+}
+
+.forecast-info h4 {
+    font-size: var(--text-base);
+    font-weight: 600;
+    color: var(--color-text);
+    margin-bottom: var(--space-1);
+}
+
+.forecast-description {
+    font-size: var(--text-xs);
+    color: var(--color-text-secondary);
+}
+
+.forecast-controls {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-3);
+    align-items: flex-end;
+}
+
+.forecast-status {
+    display: flex;
+    gap: var(--space-4);
+}
+
+.forecast-status .status-item {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    text-align: right;
+}
+
+.forecast-status .status-label {
+    font-size: 10px;
+    color: var(--color-text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.forecast-status .status-value {
+    font-size: var(--text-xs);
+    font-weight: 600;
+    color: var(--color-text);
+    font-family: var(--font-mono);
+}
+
+.forecast-actions {
+    display: flex;
+    gap: var(--space-2);
+}
+
+.forecast-btn {
+    display: flex;
+    align-items: center;
+    gap: var(--space-2);
+    padding: var(--space-2) var(--space-3);
+    background: var(--color-accent);
+    border: none;
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    font-size: 10px;
+    font-weight: 600;
+    color: white;
+    transition: background 0.15s;
+    font-family: var(--font-sans);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.forecast-btn:hover:not(:disabled) {
+    background: var(--color-accent-hover);
+}
+
+.forecast-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.forecast-btn.loading svg {
+    animation: spin 1s linear infinite;
+}
+
+.forecast-chart-section {
+    margin-bottom: var(--space-4);
+    padding: var(--space-3);
+    background: var(--color-bg-elevated);
+    border-radius: var(--radius-md);
+    border: 1px solid var(--color-border);
+}
+
+.chart-legend {
+    display: flex;
+    gap: var(--space-4);
+    margin-bottom: var(--space-3);
+    flex-wrap: wrap;
+}
+
+.legend-item {
+    display: flex;
+    align-items: center;
+    gap: var(--space-2);
+    font-size: 10px;
+    color: var(--color-text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+}
+
+.legend-color {
+    width: 16px;
+    height: 3px;
+    border-radius: 2px;
+}
+
+.legend-item.historical .legend-color {
+    background: var(--color-accent);
+}
+
+.legend-item.predicted .legend-color {
+    background: var(--color-positive);
+    background-image: linear-gradient(90deg, var(--color-positive) 60%, transparent 60%);
+    background-size: 6px 3px;
+}
+
+.legend-item.confidence .legend-color {
+    background: rgba(16, 185, 129, 0.25);
+    height: 10px;
+    width: 20px;
+}
+
+#forecastChart {
+    width: 100%;
+    height: 300px;
+    background: var(--color-bg-subtle);
+    border-radius: var(--radius-sm);
+}
+
+.forecast-disclaimer {
+    padding: var(--space-3);
+    background: var(--color-negative-bg);
+    border-radius: var(--radius-sm);
+    border: 1px solid var(--color-negative);
+    border-left: 3px solid var(--color-negative);
+}
+
+.forecast-disclaimer p {
+    font-size: var(--text-xs);
+    color: var(--color-negative);
+    line-height: 1.5;
+    margin: 0;
+}
+
+.forecast-disclaimer strong {
+    font-weight: 700;
+}
+
+/* ============================================
+   Responsive Design
+   ============================================ */
+
+@media (max-width: 1024px) {
+    .metrics-grid {
+        grid-template-columns: repeat(3, 1fr);
+    }
+}
+
+@media (max-width: 768px) {
+    :root {
+        --chat-width: 100%;
+    }
+
+    .app-layout {
+        grid-template-columns: 1fr;
+    }
+
+    .chat-panel {
+        position: fixed;
+        right: 0;
+        top: var(--header-height);
+        height: calc(100vh - var(--header-height));
+        width: 100%;
+        transform: translateX(100%);
+        transition: transform 0.25s ease;
+        z-index: 1000;
+    }
+
+    .chat-panel.open {
+        transform: translateX(0);
+    }
+
+    .close-mobile-chat {
+        display: block;
+    }
+
+    /* Mobile chat toggle button */
+    .mobile-chat-toggle {
+        position: fixed;
+        right: var(--space-4);
+        bottom: var(--space-4);
+        width: 48px;
+        height: 48px;
+        background: var(--color-accent);
+        color: white;
+        border: none;
+        border-radius: 50%;
+        cursor: pointer;
+        box-shadow: var(--shadow-lg);
+        z-index: 999;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: var(--text-lg);
+    }
+
+    .main-content {
+        padding: var(--space-3);
+    }
+
+    .global-header {
+        padding: 0 var(--space-4);
+    }
+
+    .global-header h1 {
+        font-size: var(--text-base);
+    }
+
+    .stock-header {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: var(--space-2);
+    }
+
+    .stock-header h2 {
+        font-size: var(--text-lg);
+    }
+
+    .stock-price {
+        font-size: var(--text-xl);
+    }
+
+    .metrics-grid {
+        grid-template-columns: repeat(2, 1fr);
+    }
+
+    .tabs {
+        -webkit-overflow-scrolling: touch;
+    }
+
+    .tab-button {
+        padding: var(--space-2) var(--space-3);
+        font-size: 10px;
+    }
+
+    #priceChart {
+        height: 200px;
+    }
+
+    .source-breakdown {
+        grid-template-columns: 1fr;
+    }
+
+    .financial-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .sentiment-aggregate {
+        flex-direction: column;
+        gap: var(--space-3);
+    }
+
+    .forecast-header {
+        flex-direction: column;
+    }
+
+    .forecast-controls {
+        width: 100%;
+        align-items: flex-start;
+    }
+}
+
+@media (max-width: 480px) {
+    .metrics-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .chart-controls {
+        flex-wrap: wrap;
+    }
+
+    .header-actions {
+        gap: var(--space-2);
+    }
+
+    .market-status {
+        display: none;
+    }
+}