Deploy to Hugging Face Space

.gitattributes

@@ -0,0 +1 @@
+*.db filter=lfs diff=lfs merge=lfs -text

.github/workflows/hf_deploy.yml

@@ -0,0 +1,83 @@
+name: Deploy to Hugging Face Spaces
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.9'
+
+      - name: Install dependencies
+        run: pip install huggingface_hub
+
+      - name: Ensure Space Exists
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_USERNAME: ${{ secrets.HF_USERNAME }}
+          SPACE_NAME: mlstocks
+        run: |
+          python -c "
+          from huggingface_hub import create_repo
+          import os
+          
+          token = os.environ['HF_TOKEN']
+          user = os.environ['HF_USERNAME']
+          space_name = os.environ['SPACE_NAME']
+          repo_id = f'{user}/{space_name}'
+          
+          print(f'Checking/Creating Space: {repo_id}')
+          try:
+              create_repo(
+                  repo_id=repo_id, 
+                  token=token, 
+                  repo_type='space', 
+                  space_sdk='docker',
+                  exist_ok=True
+              )
+              print('Space is ready.')
+          except Exception as e:
+              print(f'Error creating space: {e}')
+              exit(1)
+          "
+
+      - name: Push to Hugging Face Hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_USERNAME: ${{ secrets.HF_USERNAME }}
+          SPACE_NAME: mlstocks
+        run: |
+          # 1. Configure Identity
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+          
+          # 2. DELETE existing git history to destroy any traces of binary blobs
+          rm -rf .git
+          
+          # 3. Initialize fresh repo for deployment
+          git init
+          git lfs install
+          
+          # 4. Enforce LFS for .db files
+          echo "*.db filter=lfs diff=lfs merge=lfs -text" > .gitattributes
+          
+          # 5. Add files (LFS filter will apply now because .gitattributes exists before add)
+          git add .
+          
+          # 6. Commit
+          git commit -m "Deploy to Hugging Face Space"
+          
+          # 7. Push
+          git remote add space https://$HF_USERNAME:$HF_TOKEN@huggingface.co/spaces/$HF_USERNAME/$SPACE_NAME
+          git push --force space master:main

.gitignore

@@ -0,0 +1,140 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.*
+.venv
+!.env.example
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# Sveltekit cache directory
+.svelte-kit/
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# Firebase cache directory
+.firebase/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v3
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+# Vite logs files
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*

Dockerfile

@@ -0,0 +1,47 @@
+# Stage 1: Build the frontend
+FROM node:20 as frontend-builder
+
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm install
+COPY frontend/ ./
+RUN npm run build
+
+# Stage 2: Build the backend and serve everything
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Copy backend code
+COPY backend/ ./backend
+
+# Corrected: Copy built frontend assets to backend/static (where main.py expects them)
+COPY --from=frontend-builder /app/frontend/dist ./backend/static
+
+# Install backend dependencies
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+# Install backend dependencies using uv into a virtual environment
+# We install from the /app/backend directory where pyproject.toml is located
+WORKDIR /app/backend
+RUN uv venv /app/.venv
+RUN uv pip install .
+
+# Reset workdir
+WORKDIR /app
+
+# Enable venv
+ENV VIRTUAL_ENV=/app/.venv
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Environment variables
+ENV PORT=7860
+ENV FRONTEND_URL=""
+ENV PYTHONPATH="/app/backend"
+
+# Expose the port
+EXPOSE 7860
+
+# Command to run the application
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port $PORT"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 startrek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,92 @@
+---
+title: AI Model Driven Trading Intelligence
+emoji: 📝
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: true
+---
+
+
+# 🧠 NEXUS Trading Intelligence Platform
+
+**AI-Driven Financial Analysis & Automated Model Architecture**
+
+MLStocks (NEXUS) is an advanced, open-source trading intelligence platform that unifies **Classical Machine Learning**, **Deep Learning**, and **Agentic AI** into a single workflow. It allows traders and developers to build, backtest, and deploy predictive models without writing complex pipelines from scratch.
+
+---
+
+## � Key Intelligence Engines
+
+### 1. 🏛️ NEXUS Quadrant (Classical Intelligence)
+Dedicated to robust, statistical market modeling.
+- **Algorithms**: Random Forest, XGBoost, Linear Regression, SVM.
+- **Use Case**: Identifying rigid price structures, support/resistance clustering, and factor-based alpha generation.
+- **Workflow**: Auto-training pipelines with hyperparameter optimization.
+
+### 2. � NEXUS Neural (Deep Intelligence)
+A cutting-edge deep learning environment for non-linear pattern recognition.
+- **Architectures**: LSTM (Long Short-Term Memory), GRU, and Transformer-based time-series models.
+- **Use Case**: Predicting complex sequential patterns, volatility shifts, and sentiment-market correlations.
+
+### 3. 🤖 Option Strategy Architect (Agentic AI)
+A multi-agent autonomous team that debates and structures option trades in real-time.
+- **The Team**:
+  - `📊 Market Analyst`: Scrapes technicals and volume profiles.
+  - `📰 Sentiment Analyst`: Parses news for event-driven risks.
+  - `🧠 Strategy Advisor`: Proposes complex option spreads (Iron Condors, Verticals).
+  - `🛡️ Risk Manager`: Validates capital exposure and final probability.
+- **Output**: A final "Trade" or "Wait" decision with specific entry/exit criteria.
+
+---
+
+## 🛠️ Technology Stack
+
+- **Frontend**: Vue 3, Vite, TailwindCSS (Glassmorphism UI).
+- **Backend**: FastAPI (Python 3.10+), Uvicorn.
+- **Database**: Neon PostgreSQL (Async SQLAlchemy).
+- **AI/LLM**: Google Gemini 2.0 Flash / Llama 3 (via Ollama/Groq), Scikit-Learn, PyTorch.
+- **Deployment**: Docker (Monolithic), Hugging Face Spaces.
+
+---
+
+## 🚀 Getting Started
+
+### Local Development
+```bash
+# 1. Clone the repository
+git clone https://github.com/mishrabp/mlstocks.git
+cd mlstocks
+
+# 2. Setup Backend
+cd backend
+python -m venv .venv
+source .venv/bin/activate  # or .venv\Scripts\activate on Windows
+pip install -r requirements.txt
+# Create .env file with NEON_DB_CONNECTION and GOOGLE_API_KEY
+
+# 3. Setup Frontend
+cd ../frontend
+npm install
+npm run dev
+```
+
+### Docker Deployment
+The project is configured for a single-container deployment suitable for Hugging Face Spaces.
+
+```bash
+docker build -t nexus-platform .
+docker run -p 7860:7860 --env-file backend/.env nexus-platform
+```
+
+---
+
+## 🔒 Security & Privacy
+- **No Data Storage**: Market data is processed in-memory or ephemeral sessions.
+- **API Keys**: All keys (OpenAI, Gemini, HF) are stored in secure environment variables.
+- **Compliance**: This tool is for **educational and research purposes only**.
+
+---
+
+## ⚠️ Disclaimer
+**Using this software does not guarantee profits.** Trading stocks, options, and futures involves substantial risk of loss. The AI agents and models provided in NEXUS are for informational assistance only and should not be construed as financial advice. Always perform your own due diligence.

backend/README.md

@@ -0,0 +1,48 @@
+# MLStocks Backend
+
+The AI-driven backbone of the MLStocks intelligence platform, orchestrating multi-agent analysis and automated model building.
+
+## 🚀 Key Features
+- **Agentic Analyst**: A multi-agent team (Market, Sentiment, Strategy, Risk) powered by AutoGen and Google Gemini for real-time options analysis.
+- **NEXUS Model Builders**: 
+  - **NEXUS Quadrant**: Classic ML pipeline (Scikit-Learn, XGBoost).
+  - **NEXUS Neural**: Deep Learning engine (PyTorch, LSTMs, Transformers).
+- **Hugging Face Hub Integration**: Automated publishing of trained models with dynamic README/Model Card generation.
+- **Data Engine**: Real-time market data synchronization and technical indicator calculation via Yahoo Finance and `ta`.
+
+## 🛠️ Technology Stack
+- **Framework**: FastAPI (Python 3.10+)
+- **LLM Orchestration**: AutoGen (Microsoft)
+- **AI Models**: Google Gemini 2.0/1.5 Flash
+- **Database**: SQLite with SQLAlchemy (Asynchronous)
+- **ML Frameworks**: Scikit-Learn, PyTorch, XGBoost
+
+## 📦 Setup & Installation
+
+1. **Environment Setup**:
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate  # Linux/WSL
+   pip install -e .
+   ```
+
+2. **Configuration**:
+   Create a `.env` file in the `backend/` directory:
+   ```env
+   GOOGLE_API_KEY=your_gemini_key
+   HF_TOKEN=your_huggingface_token
+   SECRET_KEY=your_jwt_secret
+   ```
+
+## 🏃 Running the Server
+```bash
+python main.py
+```
+The API documentation will be available at `http://localhost:8000/docs`.
+
+### 📂 Structure
+- `app/api/`: FastAPI route definitions.
+- `app/agentic_analyst/`: Multi-agent team logic and tool definitions.
+- `app/model_builder/`: ML training and publishing orchestration.
+- `app/core/`: Configuration, authentication, and model factory.
+- `app/models/`: Database schema and Pydantic models.

backend/app/agentic_analyst/__init__.py

@@ -0,0 +1,4 @@
+# Agentic Analyst Module
+from .team import get_trading_team, extract_json
+
+__all__ = ['get_trading_team', 'extract_json']

backend/app/agentic_analyst/agents/__init__.py

@@ -0,0 +1 @@
+# Agents module

backend/app/agentic_analyst/agents/market_analyst.py

@@ -0,0 +1,36 @@
+from autogen_agentchat.agents import AssistantAgent
+import datetime
+from autogen_core.tools import FunctionTool
+from app.agentic_analyst.tools.market_data import get_current_price, get_historical_volatility, get_option_chain_snapshot, get_technical_indicators
+
+def get_market_analyst(model_client):
+    
+    # Wrap tools
+    price_tool = FunctionTool(get_current_price, description="Get current price of a stock.")
+    vol_tool = FunctionTool(get_historical_volatility, description="Get historical volatility and VIX context.")
+    chain_tool = FunctionTool(get_option_chain_snapshot, description="Get option chain snapshot for near-term expiry.")
+    tech_tool = FunctionTool(get_technical_indicators, description="Calculate SMA (20/50/200) and RSI (14) technical indicators.")
+
+    return AssistantAgent(
+        name="MarketAnalyst",
+        model_client=model_client,
+        tools=[price_tool, vol_tool, chain_tool, tech_tool],
+        system_message=f"""
+        You are a Market Technician. Today is {datetime.date.today()}.
+        1. Fetch Price, Volatility, Option Chain, AND Technical Indicators (SMA, RSI) for the ticker.
+        2. Analyze the Trend (Bullish/Bearish/Neutral) based on price action and SMA alignment (Price vs SMA200).
+        3. Analyze the Volatility Regime (Low/Normal/High) using HV and VIX.
+        4. Analyze Momentum: Check RSI levels (Overbought > 70 / Oversold < 30).
+        5. Output a JSON similar to:
+           {{
+             "ticker": "...",
+             "price": ...,
+             "trend": "...",
+             "volatility": "...",
+             "rsi_status": "Overbought/Neutral/Oversold",
+             "liquidity_check": "Pass/Fail based on option chain availability",
+             "notes": "..."
+           }}
+        Do NOT recommend a trade yet. Just analyze the context.
+        """
+    )

backend/app/agentic_analyst/agents/risk_manager.py

@@ -0,0 +1,28 @@
+from autogen_agentchat.agents import AssistantAgent
+import datetime
+
+def get_risk_manager(model_client):
+    
+    return AssistantAgent(
+        name="RiskManager",
+        model_client=model_client,
+        system_message=f"""
+        You are the Chief Risk Officer. Today is {datetime.date.today()}.
+        1. Review the proposed strategy and confidence score.
+        2. STRICT RULE: If confidence < 70, reject the trade and recommend "WAIT".
+        3. Validate the score calculation against the Rubric (Start 50 + Trend/Vol/Sentiment addons).
+        4. Event Risk Check: If Earnings/CPI imminent, override and recommend "WAIT".
+        
+        Output final JSON:
+           {{
+             "final_decision": "TRADE | WAIT",
+             "confidence": ..., // The final validated score
+             "actionable_recommendation": "Execute Bull Call Spread... / Stay in Cash",
+             "entry_signal": "Net Credit | Net Debit",
+             "entry_price": 1.50,
+             "risk_warning": "..."
+           }}
+        
+        End your response with the word TERMINATE to signal completion.
+        """
+    )

backend/app/agentic_analyst/agents/sentiment_analyst.py

@@ -0,0 +1,29 @@
+from autogen_agentchat.agents import AssistantAgent
+import datetime
+from autogen_core.tools import FunctionTool
+from app.agentic_analyst.tools.news_data import search_news
+
+def get_sentiment_analyst(model_client):
+    
+    news_tool = FunctionTool(search_news, description="Search for recent news about the ticker.")
+
+    return AssistantAgent(
+        name="SentimentAnalyst",
+        model_client=model_client,
+        tools=[news_tool],
+        system_message=f"""
+        You are a Sentiment Analyst. Today is {datetime.date.today()}.
+        1. Search for recent news. The results now include **FinBERT Sentiment Scores** (e.g. [FinBERT: positive (0.95)]).
+        2. Aggregate these FinBERT scores to determine the overall sentiment (Bullish/Bearish/Neutral).
+        3. Assign a 'Sentiment Confidence' score based on the FinBERT probability scores.
+           - If multiple articles have >0.90 positive/negative, confidence is HIGH.
+           - If signals are mixed or low probability, confidence is LOW/MEDIUM.
+        4. Output JSON:
+           {{
+             "sentiment": "...",
+             "confidence": "...",
+             "key_events": ["..."],
+             "risk_factors": ["..."]
+           }}
+        """
+    )

backend/app/agentic_analyst/agents/strategy_advisor.py

@@ -0,0 +1,41 @@
+from autogen_agentchat.agents import AssistantAgent
+import datetime
+
+def get_strategy_advisor(model_client):
+    
+    return AssistantAgent(
+        name="StrategyAdvisor",
+        model_client=model_client,
+        system_message=f"""
+        You are an Option Strategist. Today is {datetime.date.today()}.
+        1. Review the Market Analysis (Trend, Volatility, Option Chain) and Sentiment Analysis.
+        2. Select a specific strategy with EXPLICIT STRIKES and EXPIRY from the provided option chain.
+        
+        RULES:
+        - HIGH Volatility + Range Bound -> Iron Condor (Credit)
+        - HIGH Volatility + Directional -> Credit Spread (Bull Put / Bear Call)
+        - LOW Volatility + Directional -> Debit Spread (Bull Call / Bear Put)
+        - LOW Volatility + Range Bound -> Calendar Spread (or WAIT)
+        
+        CONFIDENCE SCORE RUBRIC (Start at 50):
+        1. Technical Trend Aligns with Strategy (Price vs SMA200): +20
+        2. Volatility Regime Aligns (e.g. High Vol/VIX > 20 for Credit): +10
+        3. Sentiment Analysis is Confirming (Same direction): +10
+        4. Technical Momentum Confluence (RSI isn't fighting the trade): +10
+        5. Option Liquidity is Sufficient: +10
+        6. Conflicting Signals (Trend vs Sentiment mismatch): -20
+        
+        CALCULATE the score explicitly based on this rubric.
+        - Target > 70% confidence for a trade recommendation.
+        
+        Output JSON:
+           {{
+             "strategy": "Bull Call Spread | Iron Condor | WAIT",
+             "confidence_score": 95, // Integer 0-100
+             "reasoning": "...",
+             "proposed_legs": "Buy 100 Call, Sell 105 Call (Exp: YYYY-MM-DD)", // MUST use actual strikes from chain
+             "entry_signal": "Net Credit | Net Debit",
+             "estimated_entry_price": 1.50 // Midpoint estimate of the spread
+           }}
+        """
+    )

backend/app/agentic_analyst/team.py

@@ -0,0 +1,42 @@
+import json
+import re
+from typing import Dict, Any
+
+from autogen_agentchat.teams import RoundRobinGroupChat
+from autogen_agentchat.conditions import MaxMessageTermination, TextMentionTermination
+
+from app.agentic_analyst.agents.market_analyst import get_market_analyst
+from app.agentic_analyst.agents.sentiment_analyst import get_sentiment_analyst
+from app.agentic_analyst.agents.strategy_advisor import get_strategy_advisor
+from app.agentic_analyst.agents.risk_manager import get_risk_manager
+
+def get_trading_team(model_client):
+    """
+    Creates and returns the RoundRobinGroupChat team.
+    """
+    print("[DEBUG] Initializing trading team agents...")
+    market = get_market_analyst(model_client)
+    sentiment = get_sentiment_analyst(model_client)
+    strategy = get_strategy_advisor(model_client)
+    risk = get_risk_manager(model_client)
+
+    print("[DEBUG] Creating RoundRobinGroupChat team...")
+    team = RoundRobinGroupChat(
+        participants=[market, sentiment, strategy, risk],
+        termination_condition=TextMentionTermination("TERMINATE") | MaxMessageTermination(20)
+    )
+    return team
+
+def extract_json(text: str) -> Dict[str, Any]:
+    """Helper to extract JSON from markdown code blocks or raw text."""
+    print("[DEBUG] Attempting to extract JSON from agent response...")
+    try:
+        match = re.search(r"```json\s*(.*?)\s*```", text, re.DOTALL)
+        if match:
+            print("[DEBUG] Found JSON matching markdown block.")
+            return json.loads(match.group(1))
+        print("[DEBUG] No markdown block found, trying raw parse.")
+        return json.loads(text)
+    except Exception as e:
+        print(f"[DEBUG] JSON extraction failed: {str(e)}")
+        return {}

backend/app/agentic_analyst/tools/__init__.py

@@ -0,0 +1 @@
+# Tools module

backend/app/agentic_analyst/tools/market_data.py

@@ -0,0 +1,228 @@
+import yfinance as yf
+import pandas as pd
+import math
+from datetime import datetime, timedelta
+
+def check_and_fix_ticker(symbol: str) -> str:
+    """
+    Checks if the ticker has data. If not, tries appending '.NS' (for NSE India).
+    Returns the working ticker or the original if neither works.
+    """
+    print(f"[DEBUG] check_and_fix_ticker called using: {symbol}")
+    symbol = symbol.upper().strip()
+    
+    # Try original
+    ticker = yf.Ticker(symbol)
+    try:
+        # fast_info is quick way to check validity
+        if ticker.fast_info.last_price is not None:
+             return symbol
+    except:
+        pass
+        
+    # Try .NS
+    ns_symbol = symbol + ".NS"
+    ns_ticker = yf.Ticker(ns_symbol)
+    try:
+        if ns_ticker.fast_info.last_price is not None:
+            return ns_symbol
+    except:
+        pass
+        
+    return symbol
+
+def get_current_price(symbol: str) -> float:
+    """Fetches the current market price of the stock."""
+    print(f"[DEBUG] get_current_price called for: {symbol}")
+    try:
+        # Auto-fix ticker if needed
+        symbol = check_and_fix_ticker(symbol)
+        
+        ticker = yf.Ticker(symbol)
+        price = ticker.fast_info.last_price
+        if price is None:
+            hist = ticker.history(period="1d")
+            if not hist.empty:
+                price = hist["Close"].iloc[-1]
+        
+        if price is None:
+             print(f"[DEBUG] No price data found for {symbol}")
+             return f"Error: No price data for {symbol}"
+             
+        print(f"[DEBUG] Current price for {symbol}: {price}")
+        return price
+    except Exception as e:
+        print(f"[DEBUG] Error fetching price for {symbol}: {str(e)}")
+        return f"Error fetching price for {symbol}: {str(e)}"
+
+def get_historical_volatility(symbol: str, period: str = "1mo") -> dict:
+    """
+    Calculates historical volatility and returns VIX context if available.
+    """
+    print(f"[DEBUG] get_historical_volatility called for: {symbol}")
+    try:
+        symbol = check_and_fix_ticker(symbol)
+        ticker = yf.Ticker(symbol)
+        hist = ticker.history(period=period)
+        if hist.empty:
+            return {"error": "No historical data found"}
+        
+        hist['Returns'] = hist['Close'].pct_change()
+        volatility = hist['Returns'].std() * math.sqrt(252)
+        
+        vix_price = None
+        try:
+            vix = yf.Ticker("^VIX")
+            vix_price = vix.fast_info.last_price
+        except:
+            pass
+
+        result = {
+            "ticker_used": symbol,
+            "annualized_volatility": round(volatility * 100, 2),
+            "period": period,
+            "vix_reference": round(vix_price, 2) if vix_price else "N/A"
+        }
+        print(f"[DEBUG] Historical Volatility for {symbol}: {result['annualized_volatility']}% (VIX: {result['vix_reference']})")
+        return result
+    except Exception as e:
+        print(f"[DEBUG] Error calculating volatility for {symbol}: {str(e)}")
+        return {"error": str(e)}
+
+def get_option_chain_snapshot(symbol: str) -> str:
+    """
+    Fetches a snapshot of the option chain.
+    """
+    print(f"[DEBUG] get_option_chain_snapshot called for: {symbol}")
+    try:
+        symbol = check_and_fix_ticker(symbol)
+        ticker = yf.Ticker(symbol)
+        expirations = ticker.options
+        
+        if not expirations:
+            return f"No options data found for {symbol}."
+            
+        target_date = None
+        today = datetime.now()
+        
+        for exp in expirations:
+            exp_date = datetime.strptime(exp, "%Y-%m-%d")
+            days_to_exp = (exp_date - today).days
+            # Adjusted window: 7 to 45 days to capture monthly expiries for better liquidity
+            if 7 <= days_to_exp <= 45:
+                target_date = exp
+                break
+        
+        if not target_date:
+            target_date = expirations[0]
+            
+        opt = ticker.option_chain(target_date)
+        calls = opt.calls
+        puts = opt.puts
+        
+        price_info = get_current_price(symbol)
+        if isinstance(price_info, str): return price_info
+        current_price = float(price_info)
+        
+        # Widen to +/- 15% to capture OTM strikes for credit spreads
+        lower_bound = current_price * 0.85
+        upper_bound = current_price * 1.15
+        
+        ntm_calls = calls[(calls['strike'] >= lower_bound) & (calls['strike'] <= upper_bound)]
+        ntm_puts = puts[(puts['strike'] >= lower_bound) & (puts['strike'] <= upper_bound)]
+        
+        summary = f"Option Chain Snapshot for {symbol} (Expiry: {target_date})\n"
+        summary += f"Current Spot Price: {round(current_price, 2)}\n\n"
+        
+        summary += "--- CALLS (Ask | Strike | IV) ---\n"
+        for _, row in ntm_calls.iterrows():
+            summary += f"Strike: {row['strike']} | Ask: {row['ask']} | IV: {round(row['impliedVolatility']*100, 1)}%\n"
+            
+        summary += "\n--- PUTS (Ask | Strike | IV) ---\n"
+        for _, row in ntm_puts.iterrows():
+            summary += f"Strike: {row['strike']} | Ask: {row['ask']} | IV: {round(row['impliedVolatility']*100, 1)}%\n"
+            
+        print(f"[DEBUG] Generated option chain snapshot for {symbol} with {len(ntm_calls)} calls and {len(ntm_puts)} puts.")
+        return summary
+        
+    except Exception as e:
+        print(f"[DEBUG] Error in get_option_chain_snapshot: {str(e)}")
+        return f"Error fetching option chain: {str(e)}"
+
+def get_technical_indicators(symbol: str) -> dict:
+    """
+    Calculates key technical indicators: SMA (20, 50, 200) and RSI (14).
+    Returns a dictionary of values and signals.
+    """
+    print(f"[DEBUG] get_technical_indicators called for: {symbol}")
+    try:
+        symbol = check_and_fix_ticker(symbol)
+        ticker = yf.Ticker(symbol)
+        
+        # Fetch enough history for SMA 200
+        hist = ticker.history(period="1y") 
+        if hist.empty:
+             return {"error": "No historical data found"}
+        
+        # Safe calculations
+        # SMA
+        hist['SMA_20'] = hist['Close'].rolling(window=20).mean()
+        hist['SMA_50'] = hist['Close'].rolling(window=50).mean()
+        
+        # Only calc SMA_200 if we actually have 200 points
+        if len(hist) >= 200:
+             hist['SMA_200'] = hist['Close'].rolling(window=200).mean()
+        else:
+             hist['SMA_200'] = pd.Series([None] * len(hist), index=hist.index)
+        
+        # RSI Calculation (14 periods) - needs at least 15 points
+        if len(hist) >= 15:
+            delta = hist['Close'].diff()
+            gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+            loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+            rs = gain / loss
+            hist['RSI_14'] = 100 - (100 / (1 + rs))
+        else:
+            hist['RSI_14'] = pd.Series([None] * len(hist), index=hist.index)
+        
+        current_data = hist.iloc[-1]
+        
+        # Interpretation RSI
+        rsi_val = current_data.get('RSI_14')
+        rsi_signal = "Insufficient Data"
+        if rsi_val is not None and not pd.isna(rsi_val):
+            rsi_val = round(rsi_val, 2)
+            if rsi_val > 70: rsi_signal = "Overbought"
+            elif rsi_val < 30: rsi_signal = "Oversold"
+            else: rsi_signal = "Neutral"
+        else:
+            rsi_val = "N/A"
+        
+        price = current_data['Close']
+        trend = "Neutral"
+        sma200 = current_data.get('SMA_200')
+        
+        if sma200 is not None and not pd.isna(sma200):
+            if price > sma200:
+                trend = "Bullish (Above SMA200)"
+            else:
+                trend = "Bearish (Below SMA200)"
+        else:
+             trend = "Unknown (No SMA200 Data)"
+            
+        result = {
+            "ticker": symbol,
+            "current_price": round(price, 2),
+            "sma_20": round(current_data['SMA_20'], 2) if not pd.isna(current_data.get('SMA_20')) else None,
+            "sma_50": round(current_data['SMA_50'], 2) if not pd.isna(current_data.get('SMA_50')) else None,
+            "sma_200": round(sma200, 2) if sma200 is not None and not pd.isna(sma200) else None,
+            "rsi_14": rsi_val,
+            "rsi_signal": rsi_signal,
+            "trend_signal": trend
+        }
+        print(f"[DEBUG] Technical Indicators for {symbol}: Price={result['current_price']}, Trend={trend}, RSI={rsi_signal}")
+        return result
+        
+    except Exception as e:
+        print(f"[DEBUG] Error calculating technical indicators for {symbol}: {str(e)}")
+        return {"error": str(e)}

backend/app/agentic_analyst/tools/news_data.py

@@ -0,0 +1,154 @@
+from duckduckgo_search import DDGS
+from transformers import pipeline
+import torch
+import requests
+from bs4 import BeautifulSoup
+from typing import Optional
+from pydantic import BaseModel, Field
+import concurrent.futures
+
+# Global variable for lazy loading
+_sentiment_pipeline = None
+
+def get_sentiment_pipeline():
+    """
+    Lazy loads the FinBERT pipeline.
+    """
+    print(f"[DEBUG] get_sentiment_pipeline called")
+    global _sentiment_pipeline
+    if _sentiment_pipeline is None:
+        try:
+            print("Loading FinBERT model...")
+            # Use CPU to avoid CUDA complexity if not needed, or let torch decide if fast
+            _sentiment_pipeline = pipeline("sentiment-analysis", model="ProsusAI/finbert")
+        except Exception as e:
+            print(f"Failed to load FinBERT: {e}")
+            return None
+    return _sentiment_pipeline
+
+def _fetch_page_content(url: str, timeout: int = 3) -> Optional[str]:
+    """Fetch and extract text content from a web page."""
+    print(f"[DEBUG] Fetching content: {url} (timeout: {timeout}s)...")
+    try:
+        headers = {
+            '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'
+            )
+        }
+        response = requests.get(url, headers=headers, timeout=timeout)
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.content, 'html.parser')
+
+        # Remove irrelevant elements
+        for tag in soup(["script", "style", "nav", "footer", "header", "aside"]):
+            tag.decompose()
+
+        # Extract text
+        text = soup.get_text(separator='\n', strip=True)
+
+        # Clean whitespace
+        lines = (line.strip() for line in text.splitlines())
+        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+        text = '\n'.join(chunk for chunk in chunks if chunk)
+        
+        return text
+    except Exception as e:
+        print(f"[WARNING] Failed to fetch content from {url}: {str(e)}")
+        return None
+
+# Validation Model
+class NewsArticle(BaseModel):
+    title: str = Field(..., description="The headline of the news article.")
+    link: str = Field(..., description="The direct URL to the full article.")
+    snippet: str = Field(..., description="A brief summary or body text.")
+    datetime: Optional[str] = Field(None, description="Publication date if available.")
+
+def search_news(ticker: str) -> str:
+    """
+    Searches for the latest news regarding the stock ticker using DuckDuckGo.
+    Analyzes each headline with FinBERT for sentiment.
+    Returns a summary string of the top 5 results with sentiment scores.
+    """
+    print(f"[DEBUG] search_news called with: {ticker}")
+    try:
+        if not ticker:
+            return "No ticker provided for news search."
+            
+        ticker = ticker.upper().strip()
+        query = f"{ticker} stock news financial"
+        
+        results = []
+        sentiment_pipe = get_sentiment_pipeline()
+        
+        with DDGS() as ddgs:
+            # Use 'news' backend
+            raw_results = list(ddgs.news(query, max_results=5))
+            
+            if not raw_results:
+                 return f"No recent news found for {ticker}."
+            
+            # Helper to process one item (fetch + analyze)
+            def process_news_item(raw_item):
+                try:
+                    # Validate / Map Raw Dict to Pydantic Model
+                    # DDGS returns: 'title', 'url', 'body', 'date', 'source'
+                    # We map them to our requested schema
+                    article = NewsArticle(
+                        title=raw_item.get('title', 'No Title'),
+                        link=raw_item.get('url', ''),
+                        snippet=raw_item.get('body', ''),
+                        datetime=raw_item.get('date', 'Unknown Date')
+                    )
+                except Exception as validation_err:
+                    print(f"[WARNING] Skipping invalid news item: {validation_err}")
+                    return None
+
+                # Processing using Validated Object
+                source = raw_item.get('source', 'Unknown Source') # Keep source for display
+                print(f"[DEBUG] Processing article: {article.title[:50]}... from {source}")
+                
+                # FinBERT Analysis
+                sentiment_tag = ""
+                if sentiment_pipe:
+                    try:
+                        # 1. Try to fetch full content
+                        content_to_analyze = article.title
+                        analysis_type = "Headline"
+                        
+                        if article.link:
+                            full_text = _fetch_page_content(article.link)
+                            if full_text and len(full_text) > 100:
+                                content_to_analyze = full_text
+                                analysis_type = "Full Text"
+                        
+                        # 2. Truncate for FinBERT
+                        print(f"[DEBUG] Running FinBERT on {analysis_type} for: {article.title[:50]}...")
+                        score = sentiment_pipe(content_to_analyze[:2000])[0]
+                        label = score['label']
+                        conf = round(score['score'], 2)
+                        
+                        sentiment_tag = f" [FinBERT ({analysis_type}): {label} ({conf})]"
+                        print(f"[DEBUG] Sentiment Result for {article.title[:50]}... -> {label} ({conf})")
+                    except Exception as e:
+                        print(f"[DEBUG] FinBERT/Scraping Error for {article.title[:50]}...: {str(e)}")
+                        sentiment_tag = f" [FinBERT: Error ({str(e)[:50]})]"
+
+                return f"- [{source} | {article.datetime}] {article.title}{sentiment_tag}"
+
+            # Run in parallel
+            with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+                # filter out None results from validation failures
+                results = [r for r in executor.map(process_news_item, raw_results) if r is not None]
+        
+        if not results:
+            print(f"[DEBUG] No news results processed for {ticker}")
+            return f"No recent news found for {ticker}."
+            
+        print(f"[DEBUG] Finished news search for {ticker}. Found {len(results)} valid articles.")
+        return f"Recent News for {ticker} (with FinBERT Analysis):\n" + "\n".join(results)
+        
+    except Exception as e:
+        return f"Error fetching news for {ticker}: {str(e)}"

backend/app/api/ai_builder.py

@@ -0,0 +1,105 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from typing import List, Dict, Any
+import json
+
+from app.db.session import get_db
+from app.services.user_service import user_service
+from app.models.database import UserAIModel, User as DBUser
+from app.core.auth import get_user_or_demo
+
+# Import from our new model_builder package
+from app.model_builder import (
+    ModelTrainer, 
+    ModelPublisher,
+    UniverseItemSchema,
+    ModelSaveSchema,
+    ModelResponseSchema,
+    TrainRequestSchema
+)
+
+router = APIRouter()
+
+# --- Universe Management ---
+
+@router.get("/universe", response_model=List[str])
+async def get_universe(db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    items = await user_service.get_universe(db, user.id)
+    return [item.symbol for item in items]
+
+@router.post("/universe")
+async def add_to_universe(item: UniverseItemSchema, db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    await user_service.add_to_universe(db, user.id, item.symbol, item.name)
+    return {"status": "success"}
+
+@router.post("/universe/sync-all")
+async def sync_all(db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    items = await user_service.get_universe(db, user.id)
+    for item in items:
+        await user_service.sync_historical_data(db, item.symbol)
+    return {"status": "success"}
+
+@router.get("/features-status")
+async def get_features_status(db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    return await user_service.get_features_status(db, user.id)
+
+# --- AI Model Management ---
+
+@router.get("/models", response_model=List[ModelResponseSchema])
+async def get_models(db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    result = await db.execute(
+        select(UserAIModel)
+        .where(UserAIModel.user_id == user.id)
+        .order_by(UserAIModel.created_at.desc())
+    )
+    models = result.scalars().all()
+    
+    return [
+        {
+            "id": m.id,
+            "name": m.name,
+            "model_type": m.model_type,
+            "target_symbol": m.target_symbol,
+            "created_at": m.created_at.isoformat(),
+            "metrics": json.loads(m.metrics) if m.metrics else {}
+        }
+        for m in models
+    ]
+
+@router.post("/models")
+async def save_model(data: ModelSaveSchema, db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    model = UserAIModel(
+        user_id=user.id,
+        name=data.name,
+        model_type=data.model_type,
+        target_symbol=data.target_symbol,
+        parameters=json.dumps(data.parameters),
+        metrics=json.dumps(data.metrics)
+    )
+    db.add(model)
+    await db.commit()
+    return {"status": "success", "id": model.id}
+
+@router.delete("/models/{model_id}")
+async def delete_model(model_id: int, db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    publisher = ModelPublisher(db, user.id)
+    return await publisher.delete_model(model_id)
+
+# --- Training & Publishing ---
+
+@router.post("/train")
+async def train_model(data: TrainRequestSchema, db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    trainer = ModelTrainer(db, user.id)
+    result = await trainer.train(
+        target_symbol=data.target_symbol,
+        model_type=data.model_type,
+        features=data.features,
+        test_size=data.test_size
+    )
+    return result
+
+@router.post("/models/{model_id}/upload-to-hf")
+async def upload_model_to_hf(model_id: int, db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    publisher = ModelPublisher(db, user.id)
+    return await publisher.upload_to_hf(model_id)

backend/app/api/auth.py

@@ -0,0 +1,90 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi_sso.sso.google import GoogleSSO
+from app.core.config import settings
+from app.core.auth import create_access_token
+from app.db.session import get_db
+from app.services.user_service import user_service
+from sqlalchemy.ext.asyncio import AsyncSession
+from starlette.responses import RedirectResponse
+
+router = APIRouter()
+
+google_sso = GoogleSSO(
+    client_id=settings.GOOGLE_CLIENT_ID,
+    client_secret=settings.GOOGLE_CLIENT_SECRET,
+    redirect_uri=settings.GOOGLE_REDIRECT_URI,
+    allow_insecure_http=True  # Set to False in production
+)
+
+@router.get("/google/login")
+async def google_login():
+    with google_sso:
+        return await google_sso.get_login_redirect()
+
+@router.get("/google/callback")
+async def google_callback(request: Request, db: AsyncSession = Depends(get_db)):
+    with google_sso:
+        try:
+            user_data = await google_sso.verify_and_process(request)
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Google Authentication failed: {str(e)}")
+            
+    if not user_data:
+        raise HTTPException(status_code=400, detail="Failed to get user data from Google")
+
+    # Check if user exists
+    user = await user_service.get_user_by_email(db, user_data.email)
+    if not user:
+        user = await user_service.create_user(
+            db=db,
+            email=user_data.email,
+            full_name=user_data.display_name or user_data.email,
+            avatar_url=user_data.picture,
+            google_id=user_data.id
+        )
+
+    # Record Session
+    from app.models.database import UserSession
+    session_record = UserSession(
+        user_id=user.id,
+        ip_address=request.client.host if request.client else None,
+        user_agent=request.headers.get("user-agent")
+    )
+    db.add(session_record)
+    await db.commit()
+
+    # Create access token
+    access_token = create_access_token(data={"sub": user.email})
+    
+    # Redirect back to frontend with token
+    # In a real app, you might use a more secure way to pass the token
+    import os
+    frontend_url = os.getenv("FRONTEND_URL", "http://localhost:5173")
+    return RedirectResponse(url=f"{frontend_url}/auth/callback?token={access_token}")
+
+
+
+# Fixing imports and implementing logout properly
+from app.core.auth import get_user_or_demo
+from app.models.database import UserSession, User as DBUser
+from sqlalchemy import select
+import datetime
+
+@router.post("/logout")
+async def logout_endpoint(db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    # Find the latest open session for this user
+    result = await db.execute(
+        select(UserSession)
+        .where(UserSession.user_id == user.id)
+        .where(UserSession.logout_at == None)
+        .order_by(UserSession.login_at.desc())
+        .limit(1)
+    )
+    last_session = result.scalar_one_or_none()
+    
+    if last_session:
+        last_session.logout_at = datetime.datetime.utcnow()
+        await db.commit()
+        return {"status": "success", "message": "Logged out successfully"}
+    
+    return {"status": "success", "message": "No active session found"}

backend/app/api/market.py

@@ -0,0 +1,340 @@
+from fastapi import APIRouter, Query, HTTPException, Depends
+from app.services.yahoo_finance import yahoo_finance_service
+from app.models.market import MarketIndicesResponse, SearchResponse
+from app.models.database import User, UserAgenticScan
+from app.db.session import get_db
+from app.core.auth import get_user_or_demo
+from sqlalchemy.ext.asyncio import AsyncSession
+from pydantic import BaseModel
+import json
+from typing import Optional, List, Dict, Any
+
+router = APIRouter()
+
+@router.get("/market-indices", response_model=MarketIndicesResponse)
+async def get_market_indices():
+    results = await yahoo_finance_service.get_market_indices()
+    return {"results": results}
+
+@router.get("/search", response_model=SearchResponse)
+async def search_ticker(q: str = Query(..., min_length=1)):
+    results = await yahoo_finance_service.search_tickers(q)
+    return {"results": results}
+
+
+class OptionsAnalysisRequest(BaseModel):
+    symbol: str
+    provider: str = "openai"
+
+
+class AgentLog(BaseModel):
+    source: str
+    content: str
+    avatar: str
+
+
+class OptionsAnalysisResponse(BaseModel):
+    logs: List[AgentLog]
+    result: Optional[Dict[str, Any]] = None
+
+
+@router.post("/options-analysis", response_model=OptionsAnalysisResponse)
+async def analyze_options_strategy(
+    request: OptionsAnalysisRequest,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_user_or_demo)
+):
+    """
+    Runs multi-agent analysis for option strategy recommendations.
+    Uses the local agentic_analyst module.
+    """
+    print(f"[DEBUG] POST /api/options-analysis for symbol: {request.symbol} (provider: {request.provider})")
+    try:
+        # Import required modules from local agentic_analyst
+        from app.core.model_factory import AutoGenModelFactory
+        from app.agentic_analyst.team import get_trading_team, extract_json
+        
+        # Agent icon mapping
+        AGENT_ICONS = {
+            "MarketAnalyst": "📊",
+            "SentimentAnalyst": "📰",
+            "StrategyAdvisor": "🧠",
+            "RiskManager": "🛡️",
+            "System": "🤖",
+            "User": "🕵️‍♂️"
+        }
+        
+        # Setup model based on provider
+        if request.provider == "gemini" or request.provider == "google" or request.provider == "openai":
+            # Revert to 2.0-flash as it was confirmed working previously
+            model_name = "gemini-2.0-flash"
+            family = "gemini"
+            request.provider = "google"
+        elif request.provider == "groq":
+            model_name = "llama-3.3-70b-versatile"
+            family = "groq"
+        elif request.provider == "ollama":
+            model_name = "llama3.2:3b"
+            family = "llama"
+        else:
+            # Default to Gemini
+            model_name = "gemini-2.0-flash"
+            family = "gemini"
+            request.provider = "google"
+        
+        print(f"[DEBUG] Using provider: {request.provider}, model: {model_name}")
+        
+        try:
+            model_client = AutoGenModelFactory.get_model(
+                provider=request.provider,
+                model_name=model_name,
+                temperature=0.2,
+                model_info={
+                    "family": family,
+                    "function_calling": True,
+                }
+            )
+        except Exception as e:
+            print(f"[DEBUG] Failed to initialize model client: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Error initializing model: {str(e)}")
+        
+        # Get trading team
+        print("[DEBUG] Getting trading team...")
+        team = get_trading_team(model_client)
+        
+        # Construct task
+        task = f"""
+        Perform a real-time trade analysis for {request.symbol}.
+        1. MarketAnalyst: detailed technicals.
+        2. SentimentAnalyst: news sentiment (Top 5 stories).
+        3. StrategyAdvisor: recommend a spread with >70% confidence.
+        4. RiskManager: validate. Output JSON with "final_decision" (TRADE/WAIT), "confidence", and "actionable_recommendation".
+        """
+        
+        logs = []
+        final_output = {}
+        
+        # Add user request log
+        logs.append({
+            "source": "User",
+            "content": f"Analyze {request.symbol} ({request.provider})",
+            "avatar": AGENT_ICONS["User"]
+        })
+        
+        print(f"[DEBUG] Starting team stream for {request.symbol}...")
+        print(f"[DEBUG] Task being sent to team: {task[:100]}...")
+        
+        try:
+            # Run team and collect messages
+            async for message in team.run_stream(task=task):
+                raw_source = getattr(message, 'source', 'System')
+                source = raw_source
+                
+                # Normalize source
+                if source.lower() == 'user':
+                    source = 'User'
+                
+                # Skip echoing the task prompt
+                if source == 'User' and "Perform a real-time trade analysis" in getattr(message, 'content', ''):
+                    continue
+                
+                # Progress tracking for tool calls
+                message_type = type(message).__name__
+                # print(f"[DEBUG] Processing message from {source} (Type: {message_type})")
+
+                # Check for tool calls specifically to show progress
+                if "ToolCall" in message_type:
+                    print(f"[DEBUG] {source} is executing tools...")
+
+                content = getattr(message, 'content', '')
+                
+                # Handle non-string content (like tool calls)
+                if not isinstance(content, str):
+                    if isinstance(content, list):
+                        content = "\n".join([str(c) for c in content])
+                    else:
+                        content = str(content)
+                
+                if not content:
+                    continue
+                
+                print(f"[DEBUG] Agent Message -> Source: {source}, Length: {len(content)}")
+                
+                # Add to logs
+                avatar_icon = AGENT_ICONS.get(source, "🤖")
+                logs.append({
+                    "source": source,
+                    "content": content,
+                    "avatar": avatar_icon
+                })
+                
+                # Extract final output from RiskManager
+                if source == "RiskManager":
+                    print("[DEBUG] RiskManager produced content, attempting extraction...")
+                    parsed = extract_json(content)
+                    if parsed:
+                        print(f"[DEBUG] Successfully extracted final decision: {parsed.get('final_decision')}")
+                        final_output = parsed
+        except Exception as stream_err:
+            print(f"[ERROR] Stream error during analysis: {stream_err}")
+            # Log the error but continue to return whatever we have
+            logs.append({
+                "source": "System",
+                "content": f"ERROR: Analysis interrupted. {str(stream_err)}",
+                "avatar": "⚠️"
+            })
+        
+        # Prepare final output logic with fallback
+        if not final_output and logs:
+             print("[DEBUG] No structured final output found. Attempting fallback save.")
+             # Try to find any message that looks like a conclusion or just save as incomplete
+             final_output = {
+                 "final_decision": "INCOMPLETE",
+                 "confidence": 0.0,
+                 "actionable_recommendation": "Analysis terminated early. Check logs for partial details.",
+                 "entry_price": "N/A",
+                 "risk_warning": "Abrupt termination detected."
+             }
+
+        if final_output:
+            try:
+                # Save to database
+                db_scan = UserAgenticScan(
+                    user_id=user.id,
+                    symbol=request.symbol,
+                    decision=final_output.get("final_decision", "WAIT"),
+                    confidence=float(final_output.get("confidence", 0.0)),
+                    recommendation=final_output.get("actionable_recommendation", "Analysis complete"),
+                    entry_price=str(final_output.get("entry_price", "")),
+                    raw_logs=json.dumps([{"source": l["source"], "content": l["content"]} for l in logs]),
+                    risk_warning=final_output.get("risk_warning", "")
+                )
+                db.add(db_scan)
+                await db.commit()
+                print(f"[DEBUG] Saved Agentic Scan to DB: ID {db_scan.id}")
+            except Exception as db_err:
+                print(f"[ERROR] Failed to save scan to DB: {db_err}")
+
+        print(f"[DEBUG] Analysis results ready for {request.symbol}. Logs: {len(logs)}")
+        return {
+            "logs": logs,
+            "result": final_output if final_output else None
+        }
+        
+    except ImportError as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Market analyst modules not available: {str(e)}"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Analysis failed: {str(e)}"
+        )
+
+from app.models.database import HistoricalData
+from sqlalchemy import select, desc
+
+class FeatureDataPoint(BaseModel):
+    date: str
+    close: float
+    volume: float
+    indicators: Optional[Dict[str, Any]] = None
+
+class AgenticScanSummary(BaseModel):
+    id: int
+    decision: str
+    confidence: float
+    recommendation: str
+    created_at: str
+    risk_warning: Optional[str] = None
+    entry_price: Optional[str] = None
+
+class TickerDetailResponse(BaseModel):
+    symbol: str
+    price: float
+    change: float
+    features: List[FeatureDataPoint]
+    latest_strategy: Optional[AgenticScanSummary] = None
+
+@router.get("/ticker/{symbol}", response_model=TickerDetailResponse)
+async def get_ticker_details(
+    symbol: str, 
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_user_or_demo)
+):
+    # 1. Get Live Quote
+    raw_symbol = symbol.upper()
+    try:
+        quotes = await yahoo_finance_service.get_quotes([raw_symbol])
+        quote = quotes[0] if quotes else None
+        
+        price_val = 0.0
+        change_val = 0.0
+        if quote:
+             # Handle string formatting like "+1.23", "1,234.56"
+             p = quote.price.replace(',', '')
+             if p != "N/A": price_val = float(p)
+             
+             c = quote.change.replace('+', '').replace(',', '')
+             if c != "N/A": change_val = float(c)
+    except Exception:
+        price_val = 0.0
+        change_val = 0.0
+
+    # 2. Get Historical Data (All records for full trend)
+    # Note: We need to import HistoricalData from database models first
+    hist_result = await db.execute(
+        select(HistoricalData)
+        .where(HistoricalData.symbol == raw_symbol)
+        .order_by(desc(HistoricalData.date))
+        # .limit(30) removed to show all history
+    )
+    hist_rows = hist_result.scalars().all()
+    
+    features = []
+    for row in hist_rows:
+        indicators = {}
+        if row.indicators:
+            try:
+                indicators = json.loads(row.indicators)
+            except:
+                pass
+        
+        features.append({
+            "date": row.date.strftime("%Y-%m-%d"),
+            "close": row.close,
+            "volume": row.volume,
+            "indicators": indicators
+        })
+    features.reverse() # Oldest to Newest for charting
+    
+    # 3. Get Latest Strategy
+    scan_result = await db.execute(
+        select(UserAgenticScan)
+        .where(UserAgenticScan.user_id == user.id)
+        .where(UserAgenticScan.symbol == raw_symbol)
+        .order_by(desc(UserAgenticScan.created_at))
+        .limit(1)
+    )
+    latest_scan = scan_result.scalar_one_or_none()
+    
+    scan_summary = None
+    if latest_scan:
+        scan_summary = {
+            "id": latest_scan.id,
+            "decision": latest_scan.decision,
+            "confidence": latest_scan.confidence,
+            "recommendation": latest_scan.recommendation,
+            "created_at": latest_scan.created_at.isoformat(),
+            "risk_warning": latest_scan.risk_warning,
+            "entry_price": latest_scan.entry_price
+        }
+
+    return {
+        "symbol": raw_symbol,
+        "price": price_val,
+        "change": change_val,
+        "features": features,
+        "latest_strategy": scan_summary
+    }

backend/app/api/user.py

@@ -0,0 +1,133 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.db.session import get_db
+from app.services.user_service import user_service
+from app.services.yahoo_finance import yahoo_finance_service
+from pydantic import BaseModel
+from typing import List, Optional
+from app.core.auth import get_current_user, get_authenticated_user, get_user_or_demo
+from app.models.database import User as DBUser
+
+router = APIRouter()
+
+class WatchlistItemSchema(BaseModel):
+    symbol: str
+    name: str
+    exchange: str
+
+class WatchlistEnrichedSchema(WatchlistItemSchema):
+    price: str
+    change: str
+    percentage: str
+    isPositive: bool
+
+class UserProfileSchema(BaseModel):
+    username: str
+    full_name: str
+    avatar_url: Optional[str]
+    theme: Optional[str] = "dark"
+
+class ThemeUpdateSchema(BaseModel):
+    theme: str
+
+class IndicatorsUpdateSchema(BaseModel):
+    indicators: List[str]
+
+@router.get("/profile", response_model=UserProfileSchema)
+async def get_profile(user: DBUser = Depends(get_user_or_demo)):
+    return {
+        "username": user.username or user.email.split('@')[0],
+        "full_name": user.full_name,
+        "avatar_url": user.avatar_url,
+        "theme": user.theme or "dark"
+    }
+
+@router.put("/profile/theme")
+async def update_theme(data: ThemeUpdateSchema, db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_authenticated_user)):
+    user.theme = data.theme
+    await db.commit()
+    return {"status": "success", "theme": user.theme}
+
+@router.get("/watchlist", response_model=List[WatchlistEnrichedSchema])
+async def get_watchlist(db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    items = await user_service.get_watchlist(db, user.id)
+    
+    if not items:
+        return []
+        
+    # Fetch live data for these symbols
+    symbols = [item.symbol for item in items]
+    quotes = await yahoo_finance_service.get_quotes(symbols)
+    quote_map = {q.symbol: q for q in quotes}
+    
+    results = []
+    for item in items:
+        quote = quote_map.get(item.symbol)
+        results.append({
+            "symbol": item.symbol,
+            "name": item.name,
+            "exchange": item.exchange,
+            "price": quote.price if quote else "0.00",
+            "change": quote.change if quote else "0.00",
+            "percentage": quote.percentage if quote else "0.00%",
+            "isPositive": quote.isPositive if quote else True
+        })
+    return results
+
+@router.post("/watchlist")
+async def add_to_watchlist(item: WatchlistItemSchema, db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_authenticated_user)):
+    await user_service.add_to_watchlist(
+        db, user.id, item.symbol, item.name, item.exchange
+    )
+    return {"status": "success"}
+
+@router.delete("/watchlist/{symbol}")
+async def remove_from_watchlist(symbol: str, db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_authenticated_user)):
+    await user_service.remove_from_watchlist(db, user.id, symbol)
+    return {"status": "success"}
+
+@router.get("/indicators", response_model=List[str])
+async def get_indicators(db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    return await user_service.get_indicators(db, user.id)
+
+@router.post("/indicators")
+async def update_indicators(data: IndicatorsUpdateSchema, db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_authenticated_user)):
+    await user_service.update_indicators(db, user.id, data.indicators)
+    return {"status": "success"}
+
+from app.models.database import UserAgenticScan
+from sqlalchemy import select, desc
+
+class AgenticScanSchema(BaseModel):
+    id: int
+    symbol: str
+    decision: str
+    confidence: float
+    recommendation: str
+    created_at: str
+    risk_warning: Optional[str] = None
+    # We might want entry_price too if available
+    entry_price: Optional[str] = None
+
+@router.get("/scans", response_model=List[AgenticScanSchema])
+async def get_scans(db: AsyncSession = Depends(get_db), user: DBUser = Depends(get_user_or_demo)):
+    result = await db.execute(
+        select(UserAgenticScan)
+        .where(UserAgenticScan.user_id == user.id)
+        .order_by(desc(UserAgenticScan.created_at))
+    )
+    scans = result.scalars().all()
+    
+    return [
+        AgenticScanSchema(
+            id=s.id,
+            symbol=s.symbol,
+            decision=s.decision,
+            confidence=s.confidence,
+            recommendation=s.recommendation,
+            created_at=s.created_at.isoformat(),
+            risk_warning=s.risk_warning,
+            entry_price=s.entry_price
+        )
+        for s in scans
+    ]