feat: Build complete application with all features

.gitignore

@@ -1 +1,34 @@
+
 .env
+
+venv/
+ai_env/
+.venv/
+
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+build/
+dist/
+*.egg-info/
+
+frontend/node_modules/
+
+frontend/dist/
+
+frontend/npm-debug.log*
+frontend/yarn-debug.log*
+frontend/yarn-error.log*
+
+
+.vscode/
+
+.DS_Store
+
+
+data/
+mlruns/
+
+tmp_download.py

README.md

@@ -0,0 +1,52 @@
+# Quantitative Analysis Platform
+> A multi-agent AI system designed to provide retail investors with hedge-fund-level research and insights
+
+
+## The Problem
+Retail investors are at a massive disadvantage. They lack the sophisticated tools, real-time data aggregation, and unbiased analysis that hedge funds use daily. Decisions are often driven by emotion and noise from social media, leading to poor outcomes. This platform was built to bridge that gap.
+
+## Features
+- **Multi-Agent Pipeline:** A robust, asynchronous backend where specialized AI agents collaborate to build a complete analysis.
+- **Data Agent:** Fetches real-time, comprehensive financial data for any stock.
+- **Intelligence Agent:** Scrapes Google News, Yahoo Finance, and Reddit to gather and analyze market sentiment.
+- **LLM Analyst Agent:** Utilizes **Google's Gemini 1.5 Flash** to analyze all collected data, identify trends, and generate a human-like investment thesis with a forecast and actionable strategy.
+- **Interactive Dashboard:** A clean, modern React frontend to visualize the data, including news feeds and historical price charts.
+- **Job History:** Users can view and revisit all their past analyses.
+
+
+## Tech Stack & Architecture
+
+### Frontend
+- **React (Vite):** For a fast and modern user interface.
+- **Tailwind CSS:** For professional and responsive styling.
+- **Recharts:** For beautiful and interactive data visualizations.
+- **Axios:** For seamless communication with the backend API.
+
+### Backend
+- **FastAPI:** A high-performance Python framework for building the API.
+- **Celery & Redis:** To manage the asynchronous, multi-step agent pipeline, ensuring the UI is always fast and responsive.
+- **PostgreSQL (Neon):** A scalable, serverless cloud database for storing job data.
+- **SQLAlchemy & Alembic:** For robust database interaction and schema migrations.
+- **LangChain & Google Gemini 1.5 Flash:** The core AI engine for the Analyst Agent.
+
+
+### Architecture
+```mermaid
+graph TD
+    A[User on React Frontend] -->|1. POST /jobs (ticker)| B(FastAPI Backend);
+    B -->|2. Dispatch Task| C[Redis Queue];
+    C -->|3. Pick up Job| D(Celery Worker);
+    D -->|4. Run Pipeline| E[Agent 1: Data];
+    E -->|5. Update DB| F[(Neon DB)];
+    D -->|6. Run Pipeline| G[Agent 2: Intelligence];
+    G -->|7. Update DB| F;
+    D -->|8. Run Pipeline| H[Agent 3: LLM Analyst];
+    H -->|9. Call Gemini API| I{Gemini 1.5 Flash};
+    I -->|10. Return Thesis| H;
+    H -->|11. Final Update| F;
+    A -->|12. GET /jobs/{id} (Polling)| B;
+    B -->|13. Read Status/Result| F;
+end
+
+## Local Setup
+

backend/alembic/env.py

@@ -1,68 +1,46 @@
-# backend/alembic/env.py
-
 from logging.config import fileConfig
-
 from sqlalchemy import engine_from_config
 from sqlalchemy.pool import NullPool
-
 from alembic import context
-
-# This is the crucial part: we import our app's config and models
 import sys
 import os
+
+# Make sure the app's modules can be found
 sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), '..')))
 
 from core.config import settings
 from core.database import Base
-from models.analysis_job import AnalysisJob
+# Import all your models here so Alembic can see them
+from models.analysis_job import AnalysisJob 
 
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
 config = context.config
 
-# This line is IMPORTANT: it tells Alembic to use our app's settings for the DB URL
+# Set the database URL from our application's settings
 config.set_main_option("sqlalchemy.url", settings.DATABASE_URL)
 
-# Interpret the config file for Python logging.
-# This line reads the logging configuration from alembic.ini
 if config.config_file_name is not None:
     fileConfig(config.config_file_name)
 
-# add your model's MetaData object here
-# for 'autogenerate' support
+# Set the target metadata for autogenerate
 target_metadata = Base.metadata
 
 def run_migrations_offline() -> None:
-    """Run migrations in 'offline' mode."""
     url = config.get_main_option("sqlalchemy.url")
-    context.configure(
-        url=url,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-    )
-
+    context.configure(url=url, target_metadata=target_metadata, literal_binds=True, dialect_opts={"paramstyle": "named"})
     with context.begin_transaction():
         context.run_migrations()
 
-
 def run_migrations_online() -> None:
-    """Run migrations in 'online' mode."""
     connectable = engine_from_config(
-        config.get_section(config.config_main_section, {}),
+        config.get_section(config.config_ini_section, {}),
         prefix="sqlalchemy.",
         poolclass=NullPool,
     )
-
     with connectable.connect() as connection:
-        context.configure(
-            connection=connection, target_metadata=target_metadata
-        )
-
+        context.configure(connection=connection, target_metadata=target_metadata)
         with context.begin_transaction():
             context.run_migrations()
 
-
 if context.is_offline_mode():
     run_migrations_offline()
 else:

backend/alembic/versions/{17ec047335c5_create_analysis_jobs_table.py → 7bad611f5ad5_create_initial_tables.py}

@@ -1,8 +1,8 @@
-"""Create analysis_jobs table
+"""Create initial tables
 
-Revision ID: 17ec047335c5
+Revision ID: 7bad611f5ad5
 Revises: 
-Create Date: 2025-09-01 16:55:38.619192
+Create Date: 2025-09-03 16:52:00.828276
 
 """
 from typing import Sequence, Union
@@ -12,7 +12,7 @@ import sqlalchemy as sa
 
 
 # revision identifiers, used by Alembic.
-revision: str = '17ec047335c5'
+revision: str = '7bad611f5ad5'
 down_revision: Union[str, Sequence[str], None] = None
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
@@ -21,20 +21,12 @@ depends_on: Union[str, Sequence[str], None] = None
 def upgrade() -> None:
     """Upgrade schema."""
     # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('analysis_jobs',
-    sa.Column('id', sa.UUID(), nullable=False),
-    sa.Column('ticker', sa.String(), nullable=False),
-    sa.Column('status', sa.String(), nullable=False),
-    sa.Column('result', sa.JSON(), nullable=True),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_index(op.f('ix_analysis_jobs_ticker'), 'analysis_jobs', ['ticker'], unique=False)
+    pass
     # ### end Alembic commands ###
 
 
 def downgrade() -> None:
     """Downgrade schema."""
     # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index(op.f('ix_analysis_jobs_ticker'), table_name='analysis_jobs')
-    op.drop_table('analysis_jobs')
+    pass
     # ### end Alembic commands ###

backend/celery_worker.py

@@ -1,12 +1,14 @@
 from celery import Celery
 from core.config import settings
 
-# giving app a more descriptive name
 celery = Celery(
     "quantitative_analysis_platform",
     broker=settings.CELERY_BROKER_URL,
     backend=settings.CELERY_RESULT_BACKEND,
-    include=["tasks.data_tasks", "tasks.news_tasks"] 
+    # This is the corrected list. We only have one task file now.
+    include=[
+        "tasks.main_task"
+    ]
 )
 
 celery.conf.update(
@@ -15,5 +17,4 @@ celery.conf.update(
     result_serializer="json",
     timezone="UTC",
     enable_utc=True,
-)
-
+)

backend/core/config.py

@@ -4,6 +4,7 @@ class Settings(BaseSettings):
     DATABASE_URL: str
     CELERY_BROKER_URL: str
     CELERY_RESULT_BACKEND: str
+    GOOGLE_API_KEY: str
 
     model_config = SettingsConfigDict(env_file=".env")
 

backend/core/database.py

@@ -2,6 +2,12 @@ from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker, declarative_base
 from .config import settings
 
-engine = create_engine(settings.DATABASE_URL)
+engine = create_engine(
+    settings.DATABASE_URL,
+    pool_recycle=1800, 
+    pool_pre_ping=True, 
+)
+
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
 Base = declarative_base()

backend/main.py

@@ -1,21 +1,91 @@
-# backend/main.py
+# from fastapi import FastAPI, Depends, HTTPException
+# from fastapi.middleware.cors import CORSMiddleware
+# from sqlalchemy.orm import Session
+# from uuid import UUID
+# import models.analysis_job as model
+# import schemas
+# from core.database import SessionLocal, engine
+# # Import only our single, main task
+# from tasks.main_task import run_full_analysis
+
+# # This ensures tables are created on startup (good for development)
+# model.Base.metadata.create_all(bind=engine)
+
+# app = FastAPI(
+#     title="Quantitative Analysis Platform API",
+#     version="0.1.0",
+# )
+
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # Dependency to get a database session for each API request
+# def get_db():
+#     db = SessionLocal()
+#     try:
+#         yield db
+#     finally:
+#         db.close()
+
+# @app.post("/jobs", response_model=schemas.Job, status_code=201)
+# def create_analysis_job(job_request: schemas.JobCreate, db: Session = Depends(get_db)):
+#     """
+#     Creates a new analysis job and dispatches the main background task.
+#     """
+#     db_job = model.AnalysisJob(ticker=job_request.ticker.upper())
+#     db.add(db_job)
+#     db.commit()
+#     db.refresh(db_job)
+    
+#     # Dispatch our single, all-in-one analysis task to run in the background
+#     run_full_analysis.delay(str(db_job.id), db_job.ticker)
+    
+#     # Immediately return the created job to the frontend
+#     return db_job
+
+# @app.get("/jobs/{job_id}", response_model=schemas.Job)
+# def get_job_status(job_id: UUID, db: Session = Depends(get_db)):
+#     """
+#     Allows the frontend to poll for the status and result of an analysis job.
+#     """
+#     db_job = db.query(model.AnalysisJob).filter(model.AnalysisJob.id == job_id).first()
+#     if db_job is None:
+#         raise HTTPException(status_code=404, detail="Job not found")
+#     return db_job
+
+
+
+
+
 from fastapi import FastAPI, Depends, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from sqlalchemy.orm import Session
+from sqlalchemy import desc # Import desc for ordering
 from uuid import UUID
-import models.analysis_job as model 
+from typing import List # Import List for the history endpoint
+import models.analysis_job as model
 import schemas
 from core.database import SessionLocal, engine
-from tasks.data_tasks import run_data_analysis
-from tasks.news_tasks import run_intelligence_analysis
-from celery import chain
+from tasks.main_task import run_full_analysis
 
 model.Base.metadata.create_all(bind=engine)
-app = FastAPI(title="Quantitative Analysis Platform API", version="0.1.0")
+
+app = FastAPI(
+    title="Quantitative Analysis Platform API",
+    version="0.1.0",
+)
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"]
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 def get_db():
@@ -32,19 +102,19 @@ def create_analysis_job(job_request: schemas.JobCreate, db: Session = Depends(ge
     db.commit()
     db.refresh(db_job)
     
-    # THE CRITICAL CHANGE IS HERE
-    analysis_chain = chain(
-        run_data_analysis.s(str(db_job.id), db_job.ticker),
-        # By making the signature immutable, we tell Celery to ignore
-        # the result of the previous task and only use the arguments we provide.
-        run_intelligence_analysis.s(str(db_job.id)).set(immutable=True)
-    )
-    analysis_chain.apply_async()
+    run_full_analysis.delay(str(db_job.id), db_job.ticker)
     
     return db_job
 
 @app.get("/jobs/{job_id}", response_model=schemas.Job)
 def get_job_status(job_id: UUID, db: Session = Depends(get_db)):
     db_job = db.query(model.AnalysisJob).filter(model.AnalysisJob.id == job_id).first()
-    if db_job is None: raise HTTPException(status_code=404, detail="Job not found")
-    return db_job
+    if db_job is None:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return db_job
+
+# --- NEW ENDPOINT FOR HISTORY PANEL ---
+@app.get("/jobs", response_model=List[schemas.Job])
+def get_jobs_history(db: Session = Depends(get_db)):
+    db_jobs = db.query(model.AnalysisJob).order_by(desc(model.AnalysisJob.created_at)).limit(20).all()
+    return db_jobs

backend/models/analysis_job.py

@@ -1,7 +1,23 @@
-from sqlalchemy import Column, String, JSON
+# from sqlalchemy import Column, String, JSON
+# from sqlalchemy.dialects.postgresql import UUID
+# import uuid
+# from core.database import Base
+
+# class AnalysisJob(Base):
+#     __tablename__ = "analysis_jobs"
+
+#     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+#     ticker = Column(String, nullable=False, index=True)
+#     status = Column(String, default="PENDING", nullable=False)
+#     result = Column(JSON, nullable=True)
+
+
+
+from sqlalchemy import Column, String, JSON, DateTime
 from sqlalchemy.dialects.postgresql import UUID
 import uuid
 from core.database import Base
+from datetime import datetime
 
 class AnalysisJob(Base):
     __tablename__ = "analysis_jobs"
@@ -9,4 +25,5 @@ class AnalysisJob(Base):
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     ticker = Column(String, nullable=False, index=True)
     status = Column(String, default="PENDING", nullable=False)
-    result = Column(JSON, nullable=True)
+    result = Column(JSON, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False) 

backend/requirements.txt

@@ -1,25 +1,37 @@
+# FastAPI and Server
 fastapi
 uvicorn[standard]
+gunicorn
 pydantic-settings
 
-
+# Database
 sqlalchemy
 psycopg2-binary
 alembic
 
-# task queue
+# Task Queue
 celery
-redis[redis-stack]
+redis
+
+# --- CORE DATA SCIENCE LIBS (PINNING NUMPY) ---
+numpy<2.0 # CRITICAL FIX: Pin numpy to a version compatible with pandas-ta
+pandas
+pandas-ta
+matplotlib
 
-# data agent
+# Data Agent & Prediction
 yfinance
 
-# news & sentiment agent
+# Intelligence Agent
 newspaper3k
 lxml_html_clean
+snscrape@git+https://github.com/JustAnotherArchivist/snscrape.git@master
+requests
+beautifulsoup4
+
+# AI / ML / LLM
 torch
 transformers
 sentence-transformers
-
-# special install for Twitter scraping
-snscrape@git+https://github.com/JustAnotherArchivist/snscrape.git@master
+langchain
+langchain-google-genai

backend/schemas.py

@@ -1,7 +1,57 @@
 from pydantic import BaseModel, ConfigDict
 from uuid import UUID
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 
+# --- Schemas for Intelligence Briefing ---
+class NewsArticle(BaseModel):
+    title: str
+    url: str
+    source: str
+    sentiment: str
+    sentiment_score: float
+
+class SentimentSummary(BaseModel):
+    total_items: int
+    positive: int
+    negative: int
+    neutral: int
+    error: Optional[str] = None
+
+class IntelligenceBriefing(BaseModel):
+    articles: List[NewsArticle]
+    sentiment_summary: SentimentSummary
+
+# --- Schema for our LLM Analysis ---
+class LLMReport(BaseModel):
+    llm_report: str
+    error: Optional[str] = None
+
+# --- Main Schema for the 'result' field ---
+class JobResult(BaseModel):
+    # Data Agent fields
+    ticker: Optional[str] = None
+    company_name: Optional[str] = None
+    current_price: Optional[float] = None
+    previous_close: Optional[float] = None
+    market_cap: Optional[int] = None
+    pe_ratio: Optional[float] = None
+    pb_ratio: Optional[float] = None
+    dividend_yield: Optional[float] = None
+    sector: Optional[str] = None
+    industry: Optional[str] = None
+    summary: Optional[str] = None
+    website: Optional[str] = None
+    
+    # Intelligence Agent field
+    intelligence_briefing: Optional[IntelligenceBriefing] = None
+    
+    # LLM Analyst field - THIS IS THE FIX
+    llm_analysis: Optional[LLMReport] = None
+    
+    # General error field
+    error: Optional[str] = None
+
+# --- Main Job Schemas for API endpoints ---
 class JobCreate(BaseModel):
     ticker: str
 
@@ -9,6 +59,6 @@ class Job(BaseModel):
     id: UUID
     ticker: str
     status: str
-    result: Optional[Dict[str, Any]] = None
+    result: Optional[JobResult] = None
 
     model_config = ConfigDict(from_attributes=True)

backend/tasks/advisor_tasks.py

@@ -0,0 +1,47 @@
+from celery_worker import celery
+from core.database import SessionLocal
+from models.analysis_job import AnalysisJob
+from tools.advisor_tools import generate_investment_thesis
+from uuid import UUID
+
+@celery.task
+def run_advisor_analysis(job_id: str):
+    db = SessionLocal()
+    job = None
+    final_result = ""
+    try:
+        job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+        if not job or not job.result:
+            raise ValueError(f"Job {job_id} not found or has no result data for the advisor.")
+        
+        print(f"Status - SUMMARIZING for job {job_id}...")
+        job.status = "SUMMARIZING"
+        db.commit()
+
+        current_data = job.result
+        
+        advisor_summary = generate_investment_thesis(current_data)
+        
+        new_result = current_data.copy()
+        new_result['advisor_summary'] = advisor_summary
+        job.result = new_result
+        
+        job.status = "SUCCESS" # This is the final successful step
+        db.commit()
+        
+        print(f"Advisor analysis for job {job_id} completed successfully.")
+        final_result = str(job.result)
+
+    except Exception as e:
+        print(f"Error during advisor analysis for job {job_id}: {e}")
+        if job:
+            job.status = "FAILED"
+            error_data = job.result if job.result else {}
+            error_data['error'] = f"Advisor analysis failed: {str(e)}"
+            job.result = error_data
+            db.commit()
+        final_result = f"Error: {e}"
+    finally:
+        db.close()
+        
+    return final_result

backend/tasks/analyst_tasks.py

@@ -0,0 +1,117 @@
+# from celery_worker import celery
+# from core.database import SessionLocal
+# from models.analysis_job import AnalysisJob
+# from tools.analyst_tools import get_llm_analysis
+# from uuid import UUID
+
+# @celery.task
+# def run_llm_analysis(job_id: str):
+#     db = SessionLocal()
+#     job = None
+#     try:
+#         job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#         if not job or not job.result:
+#             raise ValueError("Job not found or has no initial data.")
+
+#         job.status = "ANALYZING" # New status for the frontend
+#         db.commit()
+
+#         current_data = job.result
+#         ticker = current_data.get("ticker")
+#         company_name = current_data.get("company_name")
+#         intelligence_briefing = current_data.get("intelligence_briefing", {})
+        
+#         llm_report_data = get_llm_analysis(ticker, company_name, intelligence_briefing)
+        
+#         new_result = current_data.copy()
+#         new_result['llm_analysis'] = llm_report_data
+#         job.result = new_result
+        
+#         job.status = "SUCCESS"
+#         db.commit()
+        
+#         print(f"LLM analysis for job {job_id} completed successfully.")
+
+#     except Exception as e:
+#         print(f"Error during LLM analysis for job {job_id}: {e}")
+#         if job:
+#             job.status = "FAILED"
+#             error_data = job.result if job.result else {}
+#             error_data['error'] = f"LLM analysis failed: {str(e)}"
+#             job.result = error_data
+#             db.commit()
+#     finally:
+#         db.close()
+
+
+
+
+
+
+
+
+
+
+# from celery_worker import celery
+# from core.database import SessionLocal
+# from models.analysis_job import AnalysisJob
+# from tools.analyst_tools import get_llm_analysis
+# from uuid import UUID
+
+# @celery.task
+# def run_llm_analysis(job_id: str):
+#     with SessionLocal() as db:
+#         job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#         if not job or not job.result:
+#             print(f"Job {job_id} not found or has no data for analyst.")
+#             return
+
+#         try:
+#             job.status = "ANALYZING"
+#             db.commit()
+
+#             current_data = job.result
+#             ticker = current_data.get("ticker")
+#             company_name = current_data.get("company_name")
+#             intelligence_briefing = current_data.get("intelligence_briefing", {})
+            
+#             llm_report_data = get_llm_analysis(ticker, company_name, intelligence_briefing)
+            
+#             new_result = dict(current_data)
+#             new_result['llm_analysis'] = llm_report_data
+#             job.result = new_result
+            
+#             job.status = "SUCCESS"
+#             db.commit()
+            
+#             print(f"LLM analysis for job {job_id} completed successfully.")
+#             return "LLM analysis successful."
+#         except Exception as e:
+#             print(f"Error during LLM analysis for job {job_id}: {e}")
+#             job.status = "FAILED"
+#             error_data = job.result if job.result else {}
+#             error_data['error'] = f"LLM analysis failed: {str(e)}"
+#             job.result = error_data
+#             db.commit()
+#             return f"LLM analysis failed: {e}"
+
+
+
+
+
+
+
+
+
+
+
+from celery_worker import celery
+from tools.analyst_tools import get_llm_analysis
+
+@celery.task
+def get_llm_analysis_task(full_job_result: dict):
+    print(f"Executing get_llm_analysis_task...")
+    ticker = full_job_result.get("ticker")
+    company_name = full_job_result.get("company_name")
+    intelligence_briefing = full_job_result.get("intelligence_briefing", {})
+    return get_llm_analysis(ticker, company_name, intelligence_briefing)

backend/tasks/coordinator_task.py

@@ -0,0 +1,38 @@
+from celery_worker import celery
+from core.database import SessionLocal
+from models.analysis_job import AnalysisJob
+from uuid import UUID
+
+@celery.task(bind=True)
+def coordinator_task(self, results, job_id: str):
+    """
+    This task receives the results from all previous tasks, assembles the
+    final result, and saves it to the database ONCE.
+    """
+    print(f"Coordinator task started for job {job_id}...")
+    with SessionLocal() as db:
+        job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+        if not job:
+            print(f"Job {job_id} not found in coordinator.")
+            return
+
+        try:
+            # results[0] is from get_data_task
+            # results[1] is from get_intelligence_task
+            # results[2] is from get_llm_analysis_task
+            
+            final_result = {
+                **results[0], # Unpack the dictionary from the data task
+                "intelligence_briefing": results[1],
+                "llm_analysis": results[2],
+            }
+
+            job.result = final_result
+            job.status = "SUCCESS"
+            db.commit()
+            print(f"Coordinator task for job {job_id} successfully saved final result.")
+        except Exception as e:
+            print(f"Error in coordinator for job {job_id}: {e}")
+            job.status = "FAILED"
+            job.result = {"error": f"Final assembly failed: {str(e)}"}
+            db.commit()

backend/tasks/data_tasks.py

@@ -1,43 +1,97 @@
+# from celery_worker import celery
+# from core.database import SessionLocal
+# from models.analysis_job import AnalysisJob
+# from tools.data_tools import get_stock_data
+# from uuid import UUID
+
+# @celery.task
+# def run_data_analysis(job_id: str, ticker: str):
+#     db = SessionLocal()
+#     job = None
+#     final_result = ""
+#     try:
+#         job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#         if not job:
+#             raise ValueError(f"Job {job_id} not found in database.")
+
+#         print(f"Status - DATA_FETCHING for job {job_id}...")
+#         job.status = "DATA_FETCHING"
+#         db.commit()
+
+#         data = get_stock_data(ticker)
+        
+#         if "error" in data:
+#             raise ValueError(data["error"])
+
+#         job.result = data
+#         db.commit()
+#         print(f"Data analysis for job {job_id} completed successfully.")
+        
+#         final_result = str(job.result)
+
+#     except Exception as e:
+#         print(f"Error during data analysis for job {job_id}: {e}")
+#         if job:
+#             job.status = "FAILED"
+#             job.result = {"error": f"Data analysis failed: {str(e)}"}
+#             db.commit()
+#         final_result = f"Error: {e}"
+#     finally:
+#         db.close()
+
+#     return final_result
+
+
+
+
+
+
+
+# from celery_worker import celery
+# from core.database import SessionLocal
+# from models.analysis_job import AnalysisJob
+# from tools.data_tools import get_stock_data
+# from uuid import UUID
+
+# @celery.task
+# def run_data_analysis(job_id: str, ticker: str):
+#     with SessionLocal() as db:
+#         job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#         if not job:
+#             print(f"Job {job_id} not found.")
+#             return
+
+#         try:
+#             job.status = "DATA_FETCHING"
+#             db.commit()
+
+#             data = get_stock_data(ticker)
+#             if "error" in data:
+#                 raise ValueError(data["error"])
+
+#             job.result = data
+#             db.commit()
+#             print(f"Data analysis for job {job_id} completed successfully.")
+#             return "Data fetching successful."
+#         except Exception as e:
+#             print(f"Error during data analysis for job {job_id}: {e}")
+#             job.status = "FAILED"
+#             job.result = {"error": f"Data analysis failed: {str(e)}"}
+#             db.commit()
+#             return f"Data fetching failed: {e}"
+
+
+
+
+
+
+
+
+
 from celery_worker import celery
-from core.database import SessionLocal
-from models.analysis_job import AnalysisJob
 from tools.data_tools import get_stock_data
-from uuid import UUID
 
 @celery.task
-def run_data_analysis(job_id: str, ticker: str):
-    db = SessionLocal()
-    job = None 
-    try:
-        job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
-        if not job:
-            print(f"Job {job_id} not found in database.")
-            return
-
-        print(f"Starting data analysis for job {job_id}, ticker {ticker}...")
-        job.status = "RUNNING"
-        db.commit()
-
-        data = get_stock_data(ticker)
-
-        job.result = data
-        job.status = "SUCCESS"
-        db.commit()
-        print(f"Data analysis for job {job_id} completed successfully.")
-        
-        # get the result BEFORE closing the session
-        final_result = str(job.result)
-
-    except Exception as e:
-        print(f"Error during data analysis for job {job_id}: {e}")
-        if job: 
-            job.status = "FAILED"
-            job.result = {"error": str(e)}
-            db.commit()
-        final_result = f"Error: {e}"
-    finally:
-        # always close the database session
-        db.close()
-
-    # return the variable that is no longer attached to the session
-    return final_result
+def get_data_task(ticker: str):
+    print(f"Executing get_data_task for {ticker}...")
+    return get_stock_data(ticker)

backend/tasks/main_task.py

@@ -0,0 +1,203 @@
+# from celery_worker import celery
+# from core.database import SessionLocal
+# from models.analysis_job import AnalysisJob
+# from tools.data_tools import get_stock_data
+# from tools.news_tools import get_combined_news_and_sentiment
+# from tools.analyst_tools import get_llm_analysis
+# from uuid import UUID
+# import json
+
+# @celery.task
+# def run_full_analysis(job_id: str, ticker: str):
+#     print(f"\n--- [START] Full Analysis for Job ID: {job_id} ---")
+    
+#     # --- Stage 1: Data Fetching ---
+#     try:
+#         with SessionLocal() as db:
+#             job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#             if not job: raise ValueError("Job not found")
+#             job.status = "DATA_FETCHING"
+#             db.commit()
+#         print("[LOG] STATUS UPDATE: DATA_FETCHING")
+        
+#         data_result = get_stock_data(ticker)
+#         if "error" in data_result: raise ValueError(data_result['error'])
+#         company_name = data_result.get("company_name", ticker)
+        
+#         with SessionLocal() as db:
+#             job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#             job.result = data_result
+#             db.commit()
+#             db.refresh(job) # Force reload from DB
+#             print(f"[LOG] DB SAVE 1 (Data): Result keys are now: {list(job.result.keys())}")
+
+#     except Exception as e:
+#         print(f"!!! [FAILURE] Stage 1 (Data): {e}")
+#         # ... error handling ...
+#         return
+
+#     # --- Stage 2: Intelligence Gathering ---
+#     try:
+#         with SessionLocal() as db:
+#             job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#             job.status = "INTELLIGENCE_GATHERING"
+#             db.commit()
+#         print("[LOG] STATUS UPDATE: INTELLIGENCE_GATHERING")
+
+#         intelligence_result = get_combined_news_and_sentiment(ticker, company_name)
+        
+#         with SessionLocal() as db:
+#             job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#             current_result = dict(job.result)
+#             current_result['intelligence_briefing'] = intelligence_result
+#             job.result = current_result
+#             db.commit()
+#             db.refresh(job) # Force reload
+#             print(f"[LOG] DB SAVE 2 (Intelligence): Result keys are now: {list(job.result.keys())}")
+#     except Exception as e:
+#         print(f"!!! [FAILURE] Stage 2 (Intelligence): {e}")
+#         # ... error handling ...
+#         return
+
+#     # --- Stage 3: LLM Analysis ---
+#     try:
+#         with SessionLocal() as db:
+#             job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#             job.status = "ANALYZING"
+#             db.commit()
+#         print("[LOG] STATUS UPDATE: ANALYZING")
+
+#         with SessionLocal() as db:
+#             job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#             data_for_llm = job.result
+        
+#         llm_result = get_llm_analysis(ticker, company_name, data_for_llm.get("intelligence_briefing", {}))
+#         if "error" in llm_result: raise ValueError(llm_result['error'])
+        
+#         # --- Final Assembly and Save ---
+#         print("[LOG] Finalizing results...")
+#         with SessionLocal() as db:
+#             job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#             final_result_data = dict(job.result)
+#             final_result_data['llm_analysis'] = llm_result
+#             job.result = final_result_data
+#             job.status = "SUCCESS"
+#             db.commit()
+#             db.refresh(job)
+#             print(f"[LOG] DB SAVE 3 (Final): Result keys are now: {list(job.result.keys())}")
+        
+#         print(f"--- [SUCCESS] Full analysis for {job_id} complete. ---")
+
+#     except Exception as e:
+#         print(f"!!! [FAILURE] Stage 3 (LLM): {e}")
+#         with SessionLocal() as db:
+#             job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#             if job:
+#                 job.status = "FAILED"
+#                 error_data = job.result if job.result else {}
+#                 error_data['error'] = str(e)
+#                 job.result = error_data
+#                 db.commit()
+
+
+
+
+
+
+
+
+
+
+from celery_worker import celery
+from core.database import SessionLocal
+from models.analysis_job import AnalysisJob
+from tools.data_tools import get_stock_data
+from tools.news_tools import get_combined_news_and_sentiment
+from tools.analyst_tools import get_llm_analysis
+from uuid import UUID
+import json
+
+@celery.task
+def run_full_analysis(job_id: str, ticker: str):
+    """
+    The single, main task that orchestrates the entire analysis pipeline.
+    """
+    print(f"\n--- [START] Full Analysis for Job ID: {job_id} ---")
+    
+    # We will use one job object throughout and update it, committing as we go.
+    # This requires careful session management.
+    db = SessionLocal()
+    job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+
+    if not job:
+        print(f"Job {job_id} not found. Aborting.")
+        db.close()
+        return
+
+    try:
+        # --- Stage 1: Data Fetching ---
+        print(f"Stage 1: DATA_FETCHING for job {job_id}")
+        job.status = "DATA_FETCHING"
+        db.commit()
+        
+        data_result = get_stock_data(ticker)
+        if "error" in data_result:
+            raise ValueError(f"Data fetching failed: {data_result['error']}")
+        
+        company_name = data_result.get("company_name", ticker)
+        
+        job.result = data_result
+        db.commit()
+        print("-> Data fetching stage complete.")
+
+        # --- Stage 2: Intelligence Gathering ---
+        print(f"Stage 2: INTELLIGENCE_GATHERING for job {job_id}")
+        job.status = "INTELLIGENCE_GATHERING"
+        db.commit()
+        
+        intelligence_result = get_combined_news_and_sentiment(ticker, company_name)
+        
+        current_result = dict(job.result)
+        current_result['intelligence_briefing'] = intelligence_result
+        job.result = current_result
+        db.commit()
+        print("-> Intelligence gathering stage complete.")
+        
+        # --- Stage 3: LLM Analysis ---
+        print(f"Stage 3: ANALYZING for job {job_id}")
+        job.status = "ANALYZING"
+        db.commit()
+
+        # We need to refresh the job object to get the latest result for the LLM
+        db.refresh(job)
+        data_for_llm = job.result
+        
+        llm_result = get_llm_analysis(ticker, company_name, data_for_llm.get("intelligence_briefing", {}))
+        if "error" in llm_result:
+            raise ValueError(f"LLM analysis failed: {llm_result['error']}")
+        
+        # --- Final Assembly and Save ---
+        print("Finalizing results for job {job_id}")
+        final_result_data = dict(job.result)
+        final_result_data['llm_analysis'] = llm_result
+        
+        job.result = final_result_data
+        job.status = "SUCCESS"
+        db.commit()
+        
+        print(f"--- [SUCCESS] Full analysis for {job_id} complete. ---")
+
+    except Exception as e:
+        error_message = str(e)
+        print(f"!!! [FAILURE] Full analysis for {job_id} FAILED: {error_message}")
+        if job:
+            job.status = "FAILED"
+            # Provide a cleaner error message for the user, while keeping technical details
+            user_friendly_error = f"Analysis failed for ticker '{ticker}'. This stock may not be listed or there was a problem fetching its data. Please check the ticker symbol and try again. (Details: {error_message})"
+            
+            error_data = job.result if job.result else {}
+            error_data['error'] = user_friendly_error
+            job.result = error_data
+            db.commit()
+    finally:
+        db.close()

backend/tasks/news_tasks.py

@@ -1,43 +1,348 @@
+# # tasks/news_tasks.py - SIMPLIFIED VERSION THAT ALWAYS WORKS
+
+# from celery_worker import celery
+# from core.database import SessionLocal
+# from models.analysis_job import AnalysisJob
+# from uuid import UUID
+# import logging
+# from datetime import datetime
+# import yfinance as yf
+
+# logger = logging.getLogger(__name__)
+
+# def get_stock_basic_info(ticker: str):
+#     """Get basic stock information to create realistic content"""
+#     try:
+#         stock = yf.Ticker(ticker)
+#         info = stock.info
+#         return {
+#             'name': info.get('longName', ticker.replace('.NS', '')),
+#             'sector': info.get('sector', 'Unknown'),
+#             'industry': info.get('industry', 'Unknown'),
+#             'current_price': info.get('currentPrice', 0),
+#             'previous_close': info.get('previousClose', 0)
+#         }
+#     except Exception as e:
+#         logger.warning(f"Could not get stock info for {ticker}: {e}")
+#         return {
+#             'name': ticker.replace('.NS', ''),
+#             'sector': 'Unknown',
+#             'industry': 'Unknown', 
+#             'current_price': 0,
+#             'previous_close': 0
+#         }
+
+# def create_realistic_articles(ticker: str, company_name: str, stock_info: dict):
+#     """Create realistic articles based on stock information"""
+    
+#     # Calculate price movement for realistic sentiment
+#     current_price = stock_info.get('current_price', 0)
+#     previous_close = stock_info.get('previous_close', 0) 
+    
+#     price_change = 0
+#     if current_price and previous_close:
+#         price_change = ((current_price - previous_close) / previous_close) * 100
+    
+#     # Generate articles based on actual stock performance
+#     articles = []
+    
+#     if price_change > 2:
+#         articles.extend([
+#             {
+#                 "title": f"{company_name} Shares Rally {price_change:.1f}% on Strong Market Sentiment",
+#                 "url": f"https://finance.yahoo.com/quote/{ticker}",
+#                 "source": "Market Analysis",
+#                 "sentiment": "Positive",
+#                 "sentiment_score": 0.8
+#             },
+#             {
+#                 "title": f"Investors Show Confidence in {company_name} as Stock Gains Momentum",
+#                 "url": f"https://www.moneycontrol.com/india/stockpricequote/{ticker}",
+#                 "source": "Financial Express",
+#                 "sentiment": "Positive",
+#                 "sentiment_score": 0.7
+#             }
+#         ])
+#     elif price_change < -2:
+#         articles.extend([
+#             {
+#                 "title": f"{company_name} Stock Declines {abs(price_change):.1f}% Amid Market Volatility",
+#                 "url": f"https://finance.yahoo.com/quote/{ticker}",
+#                 "source": "Market Watch",
+#                 "sentiment": "Negative",
+#                 "sentiment_score": 0.8
+#             },
+#             {
+#                 "title": f"Market Correction Impacts {company_name} Share Price",
+#                 "url": f"https://www.moneycontrol.com/india/stockpricequote/{ticker}",
+#                 "source": "Economic Times",
+#                 "sentiment": "Negative", 
+#                 "sentiment_score": 0.6
+#             }
+#         ])
+#     else:
+#         articles.extend([
+#             {
+#                 "title": f"{company_name} Stock Shows Steady Performance in Current Market",
+#                 "url": f"https://finance.yahoo.com/quote/{ticker}",
+#                 "source": "Yahoo Finance",
+#                 "sentiment": "Neutral",
+#                 "sentiment_score": 0.5
+#             },
+#             {
+#                 "title": f"Technical Analysis: {company_name} Maintains Stable Trading Range", 
+#                 "url": f"https://www.moneycontrol.com/india/stockpricequote/{ticker}",
+#                 "source": "Market Analysis",
+#                 "sentiment": "Neutral",
+#                 "sentiment_score": 0.5
+#             }
+#         ])
+    
+#     # Add sector-specific articles
+#     sector = stock_info.get('sector', 'Unknown')
+#     if sector != 'Unknown':
+#         articles.extend([
+#             {
+#                 "title": f"{sector} Sector Update: Key Players Including {company_name} in Focus",
+#                 "url": "https://example.com/sector-analysis",
+#                 "source": "Sector Reports",
+#                 "sentiment": "Neutral",
+#                 "sentiment_score": 0.6
+#             },
+#             {
+#                 "title": f"Industry Outlook: {stock_info.get('industry', 'Market')} Trends Affecting {company_name}",
+#                 "url": "https://example.com/industry-outlook", 
+#                 "source": "Industry Analysis",
+#                 "sentiment": "Positive",
+#                 "sentiment_score": 0.6
+#             }
+#         ])
+    
+#     # Add general market articles
+#     articles.extend([
+#         {
+#             "title": f"Quarterly Performance Review: {company_name} Financials and Market Position",
+#             "url": f"https://finance.yahoo.com/quote/{ticker}/financials",
+#             "source": "Financial Reports",
+#             "sentiment": "Neutral",
+#             "sentiment_score": 0.5
+#         },
+#         {
+#             "title": f"Analyst Coverage: Investment Recommendations for {company_name} Stock",
+#             "url": "https://example.com/analyst-coverage",
+#             "source": "Research Reports", 
+#             "sentiment": "Positive",
+#             "sentiment_score": 0.7
+#         },
+#         {
+#             "title": f"Market Sentiment Analysis: Retail vs Institutional Interest in {company_name}",
+#             "url": "https://example.com/market-sentiment",
+#             "source": "Market Research",
+#             "sentiment": "Neutral",
+#             "sentiment_score": 0.5
+#         }
+#     ])
+    
+#     return articles[:8]  # Return top 8 articles
+
+# def try_real_news_sources(ticker: str, company_name: str):
+#     """Attempt to get real news, but don't fail if it doesn't work"""
+#     real_articles = []
+    
+#     try:
+#         # Try Yahoo Finance news (most reliable)
+#         logger.info(f"Attempting to fetch real Yahoo Finance news for {ticker}")
+#         stock = yf.Ticker(ticker)
+#         news = stock.news
+        
+#         if news:
+#             logger.info(f"Found {len(news)} Yahoo Finance articles")
+#             for article in news[:5]:  # Take first 5
+#                 if article.get('title'):
+#                     # Simple sentiment analysis
+#                     title_lower = article['title'].lower()
+#                     if any(word in title_lower for word in ['gain', 'rise', 'growth', 'profit', 'strong']):
+#                         sentiment = 'Positive'
+#                         score = 0.7
+#                     elif any(word in title_lower for word in ['fall', 'decline', 'loss', 'weak', 'drop']):
+#                         sentiment = 'Negative'
+#                         score = 0.7
+#                     else:
+#                         sentiment = 'Neutral'
+#                         score = 0.5
+                    
+#                     real_articles.append({
+#                         "title": article['title'].strip(),
+#                         "url": article.get('link', ''),
+#                         "source": article.get('publisher', 'Yahoo Finance'),
+#                         "sentiment": sentiment,
+#                         "sentiment_score": score,
+#                         "is_real": True
+#                     })
+        
+#         logger.info(f"Successfully retrieved {len(real_articles)} real articles")
+        
+#     except Exception as e:
+#         logger.warning(f"Could not fetch real news: {e}")
+    
+#     return real_articles
+
+# @celery.task
+# def run_intelligence_analysis(job_id: str):
+#     """Simplified intelligence analysis that always provides results"""
+#     db = SessionLocal()
+#     job = None
+    
+#     try:
+#         logger.info(f"Starting intelligence analysis for job {job_id}")
+        
+#         # Get job
+#         job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#         if not job or not job.result:
+#             raise ValueError(f"Job {job_id} not found or has no initial data.")
+        
+#         job.status = "INTELLIGENCE_GATHERING"
+#         db.commit()
+        
+#         current_data = job.result
+#         ticker = current_data.get("ticker")
+#         company_name = current_data.get("company_name", ticker.replace('.NS', ''))
+        
+#         logger.info(f"Analyzing {company_name} ({ticker})")
+        
+#         # Get basic stock information
+#         stock_info = get_stock_basic_info(ticker)
+#         logger.info(f"Stock info: {stock_info['name']} - {stock_info['sector']}")
+        
+#         # Try to get real news first
+#         real_articles = try_real_news_sources(ticker, company_name)
+        
+#         # Create realistic articles
+#         realistic_articles = create_realistic_articles(ticker, company_name, stock_info)
+        
+#         # Combine real and realistic articles
+#         all_articles = real_articles + realistic_articles
+        
+#         # Remove duplicates and limit to 10 articles
+#         seen_titles = set()
+#         unique_articles = []
+#         for article in all_articles:
+#             if article['title'] not in seen_titles:
+#                 seen_titles.add(article['title'])
+#                 unique_articles.append(article)
+        
+#         final_articles = unique_articles[:10]
+        
+#         # Count sentiments
+#         sentiment_counts = {'Positive': 0, 'Negative': 0, 'Neutral': 0}
+#         for article in final_articles:
+#             sentiment_counts[article['sentiment']] += 1
+        
+#         # Create intelligence briefing
+#         intelligence_briefing = {
+#             "articles": final_articles,
+#             "sentiment_summary": {
+#                 "total_items": len(final_articles),
+#                 "positive": sentiment_counts['Positive'],
+#                 "negative": sentiment_counts['Negative'],
+#                 "neutral": sentiment_counts['Neutral'],
+#                 "real_articles": len(real_articles),
+#                 "generated_articles": len(realistic_articles),
+#                 "analysis_timestamp": datetime.now().isoformat()
+#             }
+#         }
+        
+#         # Update job result
+#         new_result = current_data.copy()
+#         new_result['intelligence_briefing'] = intelligence_briefing
+#         job.result = new_result
+#         job.status = "INTELLIGENCE_COMPLETE"
+        
+#         db.commit()
+        
+#         logger.info(f"Intelligence analysis completed successfully:")
+#         logger.info(f"- Total articles: {len(final_articles)}")
+#         logger.info(f"- Real articles: {len(real_articles)}")
+#         logger.info(f"- Generated articles: {len(realistic_articles)}")
+#         logger.info(f"- Sentiment: {sentiment_counts}")
+        
+#         return str(job.result)
+        
+#     except Exception as e:
+#         logger.error(f"Intelligence analysis failed for job {job_id}: {e}")
+        
+#         if job:
+#             job.status = "FAILED"
+#             error_data = job.result if job.result else {}
+#             error_data['error'] = f"Intelligence analysis failed: {str(e)}"
+#             job.result = error_data
+#             db.commit()
+        
+#         return f"Error: {e}"
+        
+#     finally:
+#         db.close()
+
+
+
+
+
+
+
+
+
+# from celery_worker import celery
+# from core.database import SessionLocal
+# from models.analysis_job import AnalysisJob
+# from tools.news_tools import get_combined_news_and_sentiment
+# from uuid import UUID
+
+# @celery.task
+# def run_intelligence_analysis(job_id: str):
+#     with SessionLocal() as db:
+#         job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+#         if not job or not job.result:
+#             print(f"Job {job_id} not found or has no data for intelligence.")
+#             return
+        
+#         try:
+#             job.status = "INTELLIGENCE_GATHERING"
+#             db.commit()
+
+#             current_data = job.result
+#             ticker = current_data.get("ticker")
+#             company_name = current_data.get("company_name")
+            
+#             intelligence_briefing = get_combined_news_and_sentiment(ticker, company_name)
+            
+#             new_result = dict(current_data)
+#             new_result['intelligence_briefing'] = intelligence_briefing
+#             job.result = new_result
+            
+#             db.commit()
+#             print(f"Intelligence analysis for job {job_id} completed successfully.")
+#             return "Intelligence gathering successful."
+#         except Exception as e:
+#             print(f"Error during intelligence analysis for job {job_id}: {e}")
+#             job.status = "FAILED"
+#             error_data = job.result if job.result else {}
+#             error_data['error'] = f"Intelligence analysis failed: {str(e)}"
+#             job.result = error_data
+#             db.commit()
+#             return f"Intelligence gathering failed: {e}"
+
+
+
+
+
+
+
+
 from celery_worker import celery
-from core.database import SessionLocal
-from models.analysis_job import AnalysisJob
-from tools.news_tools import get_news_and_sentiment, get_twitter_sentiment
-from uuid import UUID
+from tools.news_tools import get_combined_news_and_sentiment
 
 @celery.task
-def run_intelligence_analysis(job_id: str):
-    db = SessionLocal()
-    job = None
-    try:
-        job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
-        if not job or not job.result: raise ValueError(f"Job {job_id} not found or has no data.")
-
-        current_data = job.result
-        company_name = current_data.get("company_name")
-        if not company_name: raise ValueError("Company name not found in data.")
-
-        print(f"Starting intelligence analysis for {company_name}...")
-        
-        news = get_news_and_sentiment(current_data.get("ticker"), company_name)
-        twitter = get_twitter_sentiment(f"{company_name} stock")
-        
-        current_data['intelligence_briefing'] = {"news": news, "twitter": twitter}
-        job.result = current_data
-        job.status = "SUCCESS"
-        db.commit()
-        
-        print(f"Intelligence analysis for job {job_id} completed.")
-        final_result = str(job.result)
-
-    except Exception as e:
-        print(f"Error during intelligence analysis for job {job_id}: {e}")
-        if job:
-            job.status = "FAILED"
-            error_data = job.result if job.result else {}
-            error_data['error'] = f"Intelligence analysis failed: {str(e)}"
-            job.result = error_data
-            db.commit()
-        final_result = f"Error: {e}"
-    finally:
-        db.close()
-    return final_result
+def get_intelligence_task(ticker: str, company_name: str):
+    print(f"Executing get_intelligence_task for {company_name}...")
+    # This task now depends on the company_name from the first task's result
+    return get_combined_news_and_sentiment(ticker, company_name)

backend/tasks/prediction_tasks.py

@@ -0,0 +1,52 @@
+from celery_worker import celery
+from core.database import SessionLocal
+from models.analysis_job import AnalysisJob
+from tools.prediction_tools import generate_forecast
+from uuid import UUID
+
+@celery.task
+def run_prediction_analysis(job_id: str):
+    db = SessionLocal()
+    job = None
+    final_result = ""
+    try:
+        job = db.query(AnalysisJob).filter(AnalysisJob.id == UUID(job_id)).first()
+        if not job or not job.result:
+            raise ValueError(f"Job {job_id} not found or has no initial data.")
+
+        print(f"Status - PREDICTING for job {job_id}...")
+        job.status = "PREDICTING"
+        db.commit()
+
+        current_data = job.result
+        ticker = current_data.get("ticker")
+        if not ticker:
+            raise ValueError("Ticker not found in initial data.")
+        
+        forecast_data = generate_forecast(ticker)
+        
+        if "error" in forecast_data:
+            raise ValueError(forecast_data["error"])
+
+        new_result = current_data.copy()
+        new_result['prediction_analysis'] = forecast_data
+        job.result = new_result
+        
+        db.commit()
+        
+        print(f"Prediction analysis for job {job_id} completed successfully.")
+        final_result = str(job.result)
+
+    except Exception as e:
+        print(f"Error during prediction analysis for job {job_id}: {e}")
+        if job:
+            job.status = "FAILED"
+            error_data = job.result if job.result else {}
+            error_data['error'] = f"Prediction analysis failed: {str(e)}"
+            job.result = error_data
+            db.commit()
+        final_result = f"Error: {e}"
+    finally:
+        db.close()
+            
+    return final_result

backend/tmp.py

@@ -0,0 +1,25 @@
+# test_news.py - Run this to test the news functionality
+from tools.news_tools import get_combined_news_and_sentiment_debug
+
+def test_news():
+    # Test with a popular Indian stock
+    ticker = "RELIANCE.NS"
+    company_name = "Reliance Industries"
+    
+    print(f"Testing news scraping for {ticker} ({company_name})")
+    result = get_combined_news_and_sentiment_debug(ticker, company_name)
+    
+    print(f"\nResults:")
+    print(f"Total articles: {result['sentiment_summary']['total_items']}")
+    print(f"Positive: {result['sentiment_summary']['positive']}")
+    print(f"Negative: {result['sentiment_summary']['negative']}")
+    print(f"Neutral: {result['sentiment_summary']['neutral']}")
+    
+    if result['articles']:
+        print(f"\nSample articles:")
+        for i, article in enumerate(result['articles'][:3]):
+            print(f"{i+1}. {article['title']}")
+            print(f"   Source: {article['source']} | Sentiment: {article['sentiment']}")
+
+if __name__ == "__main__":
+    test_news()

backend/tools/advisor_tools.py

@@ -0,0 +1,70 @@
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from typing import Dict, Any
+import json
+
+def generate_investment_thesis(full_job_result: Dict[str, Any]) -> str:
+    """
+    Uses the Gemini 1.5 Flash model to generate a qualitative investment thesis.
+    """
+    print("Generating investment thesis with Gemini 1.5 Flash...")
+
+    # Initialize the LLM
+    llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash")
+
+    # Create a simplified summary of the data to pass to the LLM
+    # This prevents sending thousands of characters of raw data
+    fundamentals_summary = (
+        f"Company: {full_job_result.get('company_name', 'N/A')}\n"
+        f"Current Price: {full_job_result.get('current_price', 'N/A')}\n"
+        f"Market Cap: {full_job_result.get('market_cap', 'N/A')}\n"
+        f"P/E Ratio: {full_job_result.get('pe_ratio', 'N/A'):.2f}\n"
+        f"Sector: {full_job_result.get('sector', 'N/A')}"
+    )
+    
+    prediction_summary = full_job_result.get('prediction_analysis', {}).get('summary', 'No prediction summary available.')
+    
+    # We need to handle the case where intelligence gathering might have failed
+    intelligence_briefing = full_job_result.get('intelligence_briefing', {})
+    if intelligence_briefing and intelligence_briefing.get('news'):
+        news_summary = ", ".join([f"'{article['title']}' ({article['sentiment']})" for article in intelligence_briefing['news'][:2]])
+    else:
+        news_summary = "No news articles found."
+
+    # Define the prompt template
+    prompt = PromptTemplate(
+        input_variables=["fundamentals", "prediction", "news"],
+        template="""
+        You are a sharp, concise senior financial analyst for an Indian market-focused fund.
+        Your task is to provide a clear investment thesis based on the data provided.
+        Do not offer financial advice. Analyze the data objectively.
+
+        **Data Overview:**
+        - **Fundamentals:** {fundamentals}
+        - **Quantitative Forecast:** {prediction}
+        - **Recent News Headlines & Sentiment:** {news}
+
+        **Your Analysis (in Markdown format):**
+        **1. Executive Summary:** A 2-sentence summary of the company's current situation based on the data.
+        **2. Bull Case:** 2-3 bullet points on the positive signals from the data.
+        **3. Bear Case:** 2-3 bullet points on the primary risks or negative signals.
+        **4. Final Recommendation:** State ONE of the following: 'Strong Buy', 'Buy', 'Hold', 'Sell', or 'Strong Sell' and provide a brief 1-sentence justification based purely on the provided data mix.
+        """
+    )
+
+    # Create the LangChain chain
+    chain = LLMChain(llm=llm, prompt=prompt)
+
+    # Run the chain with our summarized data
+    try:
+        response = chain.run(
+            fundamentals=fundamentals_summary,
+            prediction=prediction_summary,
+            news=news_summary
+        )
+        print("Successfully generated thesis from Gemini.")
+        return response
+    except Exception as e:
+        print(f"Error calling Gemini API: {e}")
+        return "Error: Could not generate the advisor summary."

backend/tools/analyst_tools.py

@@ -0,0 +1,151 @@
+import yfinance as yf
+import pandas as pd
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from typing import Dict, Any
+import time
+
+def get_llm_analysis(ticker: str, company_name: str, intelligence_briefing: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Uses Gemini 1.5 Flash to analyze historical data and news to generate
+    a forecast and a complete investment thesis.
+    """
+    print(f"Starting LLM-powered analysis for {ticker} with Gemini 1.5 Flash...")
+
+    # clean and format ticker properly
+    original_ticker = ticker
+    if not ticker.endswith(('.NS', '.BO', '.L', '.TO')):
+        # For Indian stocks, try NSE first
+        ticker = f"{ticker}.NS"
+        print(f"Formatted ticker from '{original_ticker}' to '{ticker}' for Yahoo Finance")
+
+    historical_data_text = "Could not fetch historical price data due to repeated errors."
+    
+    for attempt in range(3):
+        try:
+            print(f"Attempt {attempt + 1}/3 to download historical data for {ticker}...")
+            stock_data = yf.download(ticker, period="100d", interval="1d", progress=False)
+            
+            if not stock_data.empty:
+                # Convert to a more readable format for the LLM
+                stock_data = stock_data.round(2)  # Round to 2 decimal places
+                # Include only the last 20 days for LLM context efficiency
+                recent_data = stock_data.tail(20)
+                historical_data_text = f"Recent 20 days of data for {ticker}:\n{recent_data.to_string()}"
+                print("-> Successfully downloaded historical data.")
+                break
+            else:
+                raise ValueError("Downloaded data is empty.")
+                
+        except Exception as e:
+            print(f"-> Attempt {attempt + 1} failed: {e}")
+            # If NSE fails, try BSE
+            if attempt == 0 and ticker.endswith('.NS'):
+                ticker = f"{original_ticker}.BO"
+                print(f"Retrying with BSE ticker: {ticker}")
+            elif attempt < 2:
+                print("   Waiting 2 seconds before retrying...")
+                time.sleep(2)
+
+    # If all attempts failed, check if we can get basic info
+    if "Could not fetch historical price data" in historical_data_text:
+        try:
+            print("Attempting to get basic stock info as fallback...")
+            stock = yf.Ticker(ticker)
+            info = stock.info
+            if info and info.get('regularMarketPrice'):
+                current_price = info.get('regularMarketPrice')
+                previous_close = info.get('previousClose', current_price)
+                historical_data_text = f"Limited data available for {ticker}:\nCurrent Price: ₹{current_price}\nPrevious Close: ₹{previous_close}"
+                print("-> Got basic stock info as fallback.")
+            else:
+                print("-> No data available from any source.")
+        except Exception as e:
+            print(f"-> Fallback also failed: {e}")
+
+    # 2. Summarize the news data into a simple text block
+    articles = intelligence_briefing.get('articles', [])
+    if articles:
+        news_summary = "\n".join([f"- {article['title']} (Source: {article['source']}, Sentiment: {article['sentiment']})" for article in articles[:10]])  # Limit to 10 articles
+    else:
+        news_summary = "No recent news or social media mentions found."
+
+    # 3. Initialize the LLM
+    try:
+        llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash-latest", temperature=0.3)
+    except Exception as e:
+        print(f"Error initializing Gemini: {e}")
+        return {"error": f"Failed to initialize Gemini API: {str(e)}"}
+
+    # 4. Enhanced prompt that handles missing data gracefully
+    prompt = PromptTemplate(
+        input_variables=["ticker", "company_name", "historical_data", "news_summary"],
+        template="""
+        You are a Senior Financial Analyst for an Indian market-focused investment fund.
+        Your task is to provide a comprehensive analysis and a 30-day forecast for the stock: {ticker} ({company_name}).
+        
+        **Important Instructions:**
+        - If historical data is limited or unavailable, focus your analysis on news sentiment and general market conditions
+        - Always provide a forecast range even with limited data, but adjust confidence accordingly
+        - Base your analysis ONLY on the provided data
+
+        **Data Provided:**
+
+        1.  **Historical Price Data:**
+            ```
+            {historical_data}
+            ```
+
+        2.  **Recent News & Social Media Headlines:**
+            {news_summary}
+
+        **Your Analysis Report (in Markdown format):**
+
+        ## 30-Day Price Forecast
+
+        **Analysis:** Analyze available data (price trends if available, news sentiment, market conditions). If price data is limited, focus on sentiment analysis and sector trends.
+
+        **Predicted Range:** Provide a realistic price range for 30 days (e.g., ₹1500 - ₹1650). If no current price available, state "Unable to provide specific range due to data limitations."
+
+        **Justification:** Explain your forecast based on available information.
+
+        **Confidence:** High/Moderate/Low based on data quality and availability.
+
+        ## Investment Thesis
+
+        **Bull Case:**
+        - Point 1 based on positive signals from available data
+        - Point 2 based on news sentiment or market conditions
+        - Point 3 if sufficient data available
+
+        **Bear Case:**
+        - Point 1 based on negative signals or risks
+        - Point 2 based on market concerns
+        - Point 3 if sufficient data available
+
+        ## Actionable Strategy
+
+        **Signal:** Buy/Sell/Hold (choose one)
+
+        **Strategy:** Provide 1-2 sentences with specific actionable advice based on the analysis above.
+
+        **Risk Management:** Brief note on stop-loss or position sizing if relevant.
+        """
+    )
+
+    # 5. Run the LangChain chain with error handling
+    chain = LLMChain(llm=llm, prompt=prompt)
+    try:
+        response = chain.run(
+            ticker=ticker,
+            company_name=company_name,
+            historical_data=historical_data_text,
+            news_summary=news_summary
+        )
+        print("Successfully generated analysis from Gemini.")
+        return {"llm_report": response}
+    except Exception as e:
+        error_msg = f"Failed to generate analysis from Gemini: {str(e)}"
+        print(f"Error calling Gemini API: {e}")
+        return {"error": error_msg}

backend/tools/data_tools.py

@@ -2,42 +2,42 @@ import yfinance as yf
 from typing import Dict, Any
 
 def get_stock_data(ticker: str) -> Dict[str, Any]:
-
-    # for NSE stocks, yfinance expects the '.NS' suffix. For BSE, it's '.BO'.
-    # assume NSE by default if no suffix is provided.
     if not ticker.endswith(('.NS', '.BO')):
-        print(f"Ticker '{ticker}' has no exchange suffix. Assuming NSE and appending '.NS'.")
         ticker = f"{ticker}.NS"
 
     stock = yf.Ticker(ticker)
     
-    # yfinance can sometimes fail for certain tickers or data points.
     try:
         info = stock.info
     except Exception as e:
         print(f"Could not fetch info for {ticker}: {e}")
         return {"error": f"Invalid ticker or no data available for {ticker}"}
 
-    # check if we got a valid response
     if not info or info.get('regularMarketPrice') is None:
          return {"error": f"Invalid ticker or no data available for {ticker}"}
 
-    # select key data points relevant to analysis
+    # --- UPGRADED DATA FETCHING ---
     data = {
         "ticker": ticker,
         "company_name": info.get('longName'),
         "current_price": info.get('currentPrice') or info.get('regularMarketPrice'),
         "previous_close": info.get('previousClose'),
+        "day_high": info.get('dayHigh'),
+        "day_low": info.get('dayLow'),
+        "fifty_two_week_high": info.get('fiftyTwoWeekHigh'),
+        "fifty_two_week_low": info.get('fiftyTwoWeekLow'),
+        "volume": info.get('volume'),
+        "average_volume": info.get('averageVolume'),
         "market_cap": info.get('marketCap'),
-        "pe_ratio": info.get('trailingPE') or info.get('forwardPE'),
+        "pe_ratio": info.get('trailingPE'),
         "pb_ratio": info.get('priceToBook'),
         "dividend_yield": info.get('dividendYield'),
         "sector": info.get('sector'),
         "industry": info.get('industry'),
         "summary": info.get('longBusinessSummary'),
         "website": info.get('website'),
-        "logo_url": info.get('logo_url')
+        # Get CEO info if available
+        "ceo": next((officer['name'] for officer in info.get('companyOfficers', []) if 'CEO' in officer.get('title', '')), "N/A"),
     }
     
-    # clean up data by removing any keys with none values
     return {k: v for k, v in data.items() if v is not None}

backend/tools/download_model.py

@@ -0,0 +1,25 @@
+from sentence_transformers import CrossEncoder
+import os
+
+# Define the model name and the directory to save it to
+MODEL_NAME = 'cross-encoder/nli-roberta-base'
+MODEL_PATH = './sentiment_model'
+
+def main():
+    """
+    Downloads the specified model from Hugging Face and saves it locally.
+    """
+    print(f"Downloading model: {MODEL_NAME}")
+    
+    # Check if the directory exists
+    if not os.path.exists(MODEL_PATH):
+        os.makedirs(MODEL_PATH)
+        
+    # This command downloads the model and saves it to the specified path
+    model = CrossEncoder(MODEL_NAME)
+    model.save(MODEL_PATH)
+    
+    print(f"Model downloaded and saved to {MODEL_PATH}")
+
+if __name__ == "__main__":
+    main()

backend/tools/news_tools.py

@@ -1,86 +1,277 @@
-import snscrape.modules.twitter as sntwitter
-import newspaper
-# We will now import AutoModelForSequenceClassification and AutoTokenizer
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import torch # We need torch to process the model's output
+import yfinance as yf
+import requests
+from bs4 import BeautifulSoup
+from transformers import pipeline
+import time
+import urllib.parse
 from typing import List, Dict, Any
+import logging
 
-# We will load the model and tokenizer inside the function
-sentiment_model = None
-tokenizer = None
+# Set up logging
+logger = logging.getLogger(__name__)
+
+# --- Model Loading ---
+sentiment_pipeline = None
 MODEL_PATH = '/code/sentiment_model'
 
-def load_sentiment_model():
-    """A function to load the model and tokenizer on demand using the transformers library."""
-    global sentiment_model, tokenizer
-    if sentiment_model is None or tokenizer is None:
-        print("Loading sentiment model and tokenizer for the first time...")
-        # Load the tokenizer from the local path
-        tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
-        # Load the model from the local path
-        sentiment_model = AutoModelForSequenceClassification.from_pretrained(MODEL_PATH)
-        print("Sentiment model and tokenizer loaded.")
+def load_sentiment_pipeline():
+    global sentiment_pipeline
+    if sentiment_pipeline is None:
+        logger.info("Loading sentiment analysis pipeline...")
+        try:
+            # Try to load the custom model
+            sentiment_pipeline = pipeline('text-classification', model=MODEL_PATH, tokenizer=MODEL_PATH)
+            logger.info("Custom sentiment pipeline loaded.")
+        except Exception as e:
+            logger.warning(f"Could not load custom model ({e}), using default pipeline...")
+            try:
+                # Fallback to default sentiment analysis
+                sentiment_pipeline = pipeline('sentiment-analysis')
+                logger.info("Default sentiment pipeline loaded.")
+            except Exception as e2:
+                logger.error(f"Could not load any sentiment pipeline: {e2}")
+                # Create a dummy pipeline that always returns neutral
+                sentiment_pipeline = lambda texts, **kwargs: [{'label': 'NEUTRAL', 'score': 0.5} for _ in texts]
+
+# --- Helper function for making web requests ---
+def get_session():
+    session = requests.Session()
+    session.headers.update({
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+        'Connection': 'keep-alive',
+    })
+    return session
 
-def analyze_sentiment_with_model(text: str) -> str:
-    """Uses the loaded model to predict sentiment."""
-    # This is the standard way to use a transformers model
-    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
-    with torch.no_grad():
-        logits = sentiment_model(**inputs).logits
+# --- PRODUCTION NEWS SCRAPING TOOLS ---
+def scrape_google_news(company_name: str) -> List[Dict[str, Any]]:
+    """Scrape Google News - this is working perfectly based on your test"""
+    logger.info(f"Fetching Google News for {company_name}...")
+    articles_data = []
     
-    scores = logits.softmax(dim=1)[0].tolist()
-    sentiment_map = {0: 'Positive', 1: 'Neutral', 2: 'Negative'} # This order might be different
+    try:
+        session = get_session()
+        
+        # Try multiple query variations (your test showed this works)
+        queries = [
+            f'"{company_name}" stock',
+            f'{company_name} share price',
+            company_name
+        ]
+        
+        for query in queries:
+            try:
+                encoded_query = urllib.parse.quote(query)
+                url = f"https://news.google.com/rss/search?q={encoded_query}&hl=en&gl=US&ceid=US:en"
+                
+                response = session.get(url, timeout=15)
+                if response.status_code == 200:
+                    soup = BeautifulSoup(response.content, 'xml')
+                    items = soup.find_all('item')
+                    
+                    for item in items[:10]:  # Top 10 articles
+                        title_elem = item.find('title')
+                        if title_elem and title_elem.text:
+                            articles_data.append({
+                                "title": title_elem.text.strip(),
+                                "url": item.find('link').text if item.find('link') else '',
+                                "source": item.find('source').text if item.find('source') else 'Google News'
+                            })
+                    
+                    if articles_data:
+                        break  # Stop if we found articles
+                        
+            except Exception as e:
+                logger.error(f"Google News query '{query}' failed: {e}")
+                continue
+                
+    except Exception as e:
+        logger.error(f"Google News scraping failed: {e}")
     
-    # Let's verify the model's expected labels
-    model_labels = sentiment_model.config.id2label
-    if model_labels:
-        # e.g., {0: 'positive', 1: 'neutral', 2: 'negative'}
-        sentiment_map = {int(k): v.capitalize() for k, v in model_labels.items()}
-
-    best_index = scores.index(max(scores))
-    return sentiment_map.get(best_index, "Unknown")
-
+    logger.info(f"-> Google News returned {len(articles_data)} articles.")
+    return articles_data
 
-def get_news_and_sentiment(ticker: str, company_name: str) -> List[Dict[str, Any]]:
-    load_sentiment_model()
-    
-    print(f"Fetching news for {company_name}...")
-    search_url = f"https://news.google.com/rss/search?q={company_name.replace(' ', '+')}+stock&hl=en-IN&gl=IN&ceid=IN:en"
-    news_source = newspaper.build(search_url, memoize_articles=False, language='en')
+def scrape_yahoo_finance_news(ticker: str) -> List[Dict[str, Any]]:
+    """Yahoo Finance news scraper"""
+    logger.info(f"Fetching Yahoo Finance News for {ticker}...")
     articles_data = []
-    for article in news_source.articles[:5]:
-        try:
-            article.download(); article.parse(); article.nlp()
-            if not article.text or len(article.text) < 150: continue
+    
+    try:
+        # Try yfinance first
+        stock = yf.Ticker(ticker)
+        news = stock.news
+        
+        if news:
+            for article in news[:10]:  # Top 10
+                if article.get('title'):
+                    articles_data.append({
+                        "title": article['title'].strip(),
+                        "url": article.get('link', ''),
+                        "source": article.get('publisher', 'Yahoo Finance'),
+                    })
+        
+    except Exception as e:
+        logger.error(f"Yahoo Finance scraping failed: {e}")
+    
+    logger.info(f"-> Yahoo Finance returned {len(articles_data)} articles.")
+    return articles_data
 
-            sentiment = analyze_sentiment_with_model(article.summary)
+def scrape_reddit_mentions(company_name: str) -> List[Dict[str, Any]]:
+    """Reddit mentions scraper - working well based on your test"""
+    logger.info(f"Fetching Reddit mentions for {company_name}...")
+    mentions_data = []
+    
+    try:
+        session = get_session()
+        subreddits = ['stocks', 'investing', 'IndiaInvestments', 'SecurityAnalysis', 'ValueInvesting']
+        
+        for subreddit in subreddits:
+            try:
+                # Search queries that worked in your test
+                search_queries = [
+                    f'"{company_name}"',
+                    company_name.split()[0] if ' ' in company_name else company_name
+                ]
+                
+                for query in search_queries:
+                    search_url = f"https://www.reddit.com/r/{subreddit}/search.json"
+                    params = {
+                        'q': query,
+                        'sort': 'new',
+                        'limit': 10,
+                        'restrict_sr': 'true',
+                        't': 'month'
+                    }
+                    
+                    response = session.get(search_url, params=params, timeout=10)
+                    if response.status_code == 200:
+                        data = response.json()
+                        posts = data.get('data', {}).get('children', [])
+                        
+                        for post in posts:
+                            post_data = post.get('data', {})
+                            if post_data.get('title'):
+                                mentions_data.append({
+                                    "title": post_data['title'].strip(),
+                                    "url": f"https://reddit.com{post_data.get('permalink', '')}",
+                                    "source": f"r/{subreddit}"
+                                })
+                        
+                        if posts:
+                            break  # Found posts with this query
+                    
+                    time.sleep(0.5)  # Rate limiting
+                    
+            except Exception as e:
+                logger.error(f"Reddit r/{subreddit} failed: {e}")
+                
+            time.sleep(1)  # Rate limiting between subreddits
+            
+    except Exception as e:
+        logger.error(f"Reddit scraping failed: {e}")
+    
+    logger.info(f"-> Reddit returned {len(mentions_data)} mentions.")
+    return mentions_data
 
-            articles_data.append({
-                "title": article.title,
-                "summary": article.summary,
-                "url": article.url,
-                "sentiment": sentiment
-            })
-        except Exception as e:
-            print(f"Could not process article {article.url}: {e}")
-    return articles_data
+# --- THE MAIN TOOL FUNCTION ---
+def get_combined_news_and_sentiment(ticker: str, company_name: str) -> Dict[str, Any]:
+    """Main function that combines all news sources and analyzes sentiment"""
+    logger.info(f"Starting news analysis for {ticker} ({company_name})")
+    
+    # Load sentiment pipeline
+    load_sentiment_pipeline()
+    
+    all_sources = []
+    
+    # Collect from all sources (based on your successful test)
+    try:
+        google_articles = scrape_google_news(company_name)
+        all_sources.extend(google_articles)
+    except Exception as e:
+        logger.error(f"Google News failed: {e}")
+    
+    try:
+        yahoo_articles = scrape_yahoo_finance_news(ticker)
+        all_sources.extend(yahoo_articles)
+    except Exception as e:
+        logger.error(f"Yahoo Finance failed: {e}")
+    
+    try:
+        reddit_mentions = scrape_reddit_mentions(company_name)
+        all_sources.extend(reddit_mentions)
+    except Exception as e:
+        logger.error(f"Reddit failed: {e}")
 
-def get_twitter_sentiment(search_query: str) -> Dict[str, Any]:
-    load_sentiment_model()
+    logger.info(f"Total items collected from all sources: {len(all_sources)}")
+    
+    if not all_sources:
+        return {
+            "articles": [], 
+            "sentiment_summary": {
+                "total_items": 0, 
+                "positive": 0, 
+                "negative": 0, 
+                "neutral": 0, 
+                "error": "Could not fetch any news from any source."
+            }
+        }
+    
+    # Perform sentiment analysis
+    try:
+        titles = [item['title'] for item in all_sources if item.get('title')]
+        results = sentiment_pipeline(titles, truncation=True, max_length=512)
 
-    print(f"Fetching Twitter sentiment for '{search_query}'...")
-    tweets = [tweet.rawContent for i, tweet in enumerate(sntwitter.TwitterSearchScraper(f"{search_query} lang:en").get_items()) if i < 50]
-    if not tweets: return {"error": "No recent tweets found."}
+        # Map sentiment results back to articles
+        for i, item in enumerate(all_sources):
+            if i < len(results):
+                label = results[i]['label']
+                
+                # Normalize different label formats
+                if label.upper() in ['POSITIVE', 'POS', 'LABEL_2']:
+                    sentiment = 'Positive'
+                elif label.upper() in ['NEGATIVE', 'NEG', 'LABEL_0']:
+                    sentiment = 'Negative'
+                else:
+                    sentiment = 'Neutral'
+                
+                item['sentiment'] = sentiment
+                item['sentiment_score'] = round(results[i]['score'], 2)
+            else:
+                # Fallback: simple keyword-based sentiment
+                title_lower = item['title'].lower()
+                if any(word in title_lower for word in ['gain', 'rise', 'growth', 'profit', 'strong', 'bullish']):
+                    item['sentiment'] = 'Positive'
+                    item['sentiment_score'] = 0.7
+                elif any(word in title_lower for word in ['fall', 'decline', 'loss', 'weak', 'bearish', 'drop']):
+                    item['sentiment'] = 'Negative'
+                    item['sentiment_score'] = 0.7
+                else:
+                    item['sentiment'] = 'Neutral'
+                    item['sentiment_score'] = 0.5
 
-    counts = {'Positive': 0, 'Negative': 0, 'Neutral': 0, 'Unknown': 0}
-    for text in tweets:
-        sentiment = analyze_sentiment_with_model(text)
-        counts[sentiment] += 1
+        # Count sentiments
+        counts = {'Positive': 0, 'Negative': 0, 'Neutral': 0}
+        for item in all_sources:
+            counts[item.get('sentiment', 'Neutral')] += 1
+            
+    except Exception as e:
+        logger.error(f"Sentiment analysis failed: {e}")
+        # Fallback to neutral sentiment for all articles
+        for item in all_sources:
+            item['sentiment'] = 'Neutral'
+            item['sentiment_score'] = 0.5
+        counts = {'Positive': 0, 'Negative': 0, 'Neutral': len(all_sources)}
+    
+    result = {
+        "articles": all_sources, 
+        "sentiment_summary": {
+            "total_items": len(all_sources),
+            "positive": counts['Positive'],
+            "negative": counts['Negative'],
+            "neutral": counts['Neutral']
+        }
+    }
     
-    return {
-        "search_query": search_query,
-        "total_tweets": len(tweets),
-        "positive": counts['Positive'],
-        "negative": counts['Negative'],
-        "neutral": counts['Neutral']
-    }
+    logger.info(f"News analysis completed: {len(all_sources)} articles, {counts}")
+    return result

backend/tools/prediction_tools.py

@@ -0,0 +1,61 @@
+import yfinance as yf
+from prophet import Prophet
+import pandas as pd
+from typing import Dict, Any
+
+def generate_forecast(ticker: str) -> Dict[str, Any]:
+    print(f"Generating forecast for ticker {ticker}...")
+    
+    stock_data = yf.download(ticker, period="2y", progress=False)
+    
+    if stock_data.empty:
+        return {"error": f"Could not download historical data for {ticker}."}
+
+    # --- THE FINAL, MOST ROBUST FIX FOR THE DATAFRAME ---
+    # 1. Create a new DataFrame with only the columns we need.
+    df_prophet = stock_data[['Close']].copy()
+    # 2. Reset the index to turn the 'Date' index into a column.
+    df_prophet.reset_index(inplace=True)
+    # 3. Rename the columns to what Prophet expects.
+    df_prophet.columns = ['ds', 'y']
+    # --- END OF FIX ---
+
+    model = Prophet(
+        daily_seasonality=False,
+        weekly_seasonality=True,
+        yearly_seasonality=True,
+        changepoint_prior_scale=0.05
+    )
+    model.fit(df_prophet)
+
+    future = model.make_future_dataframe(periods=30)
+    forecast = model.predict(future)
+    
+    current_price = df_prophet['y'].iloc[-1]
+    predicted_price_30_days = forecast['yhat'].iloc[-1]
+    trend = "upward" if predicted_price_30_days > current_price else "downward"
+    change_percent = ((predicted_price_30_days - current_price) / current_price) * 100
+
+    forecast_data = {
+        "summary": (
+            f"The model predicts a {trend} trend over the next 30 days. "
+            f"Current price: {current_price:.2f}, "
+            f"predicted price in 30 days: {predicted_price_30_days:.2f} "
+            f"({change_percent:+.2f}% change)."
+        ),
+        # Convert datetime objects to strings for JSON compatibility
+        "history_plot_data": [
+            {'ds': r['ds'].isoformat(), 'y': r['y']} for r in df_prophet.tail(90).to_dict('records')
+        ],
+        "forecast_plot_data": [
+            {
+                'ds': r['ds'].isoformat(),
+                'yhat': r['yhat'],
+                'yhat_lower': r['yhat_lower'],
+                'yhat_upper': r['yhat_upper']
+            } for r in forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail(120).to_dict('records')
+        ]
+    }
+    
+    print(f"Forecast for {ticker} generated successfully.")
+    return forecast_data

docker-compose.yml

@@ -1,12 +1,14 @@
 services:
+  # --- Application Services ---
   redis:
     image: redis:7-alpine
     ports:
       - "6379:6379"
+    restart: always
 
   backend:
     build:
-      context: . # <-- Context is ROOT
+      context: .
       dockerfile: ./backend/Dockerfile
     ports:
       - "8000:8000"
@@ -14,19 +16,21 @@ services:
       - ./backend:/code/app
     env_file:
       - .env
-    command: python -m uvicorn main:app --host 0.0.0.0 --port 8000
+    command: python -m uvicorn main:app --host 0.0.0.0 --port 8000 --reload
+    restart: always
     depends_on:
       - redis
 
   worker:
     build:
-      context: . # <-- Context is ROOT
+      context: .
       dockerfile: ./backend/Dockerfile
     volumes:
       - ./backend:/code/app
     env_file:
       - .env
     command: python -m celery -A celery_worker.celery worker --loglevel=info
+    restart: always
     depends_on:
       - redis
       - backend
@@ -40,5 +44,9 @@ services:
     volumes:
       - ./frontend:/app
       - /app/node_modules
+    restart: always
     depends_on:
-      - backend
+      - backend
+
+# No other services or volumes are needed.
+# The 'mlflow' service and its 'mlflow_server_data' volume have been completely removed.

frontend/package.json

@@ -10,18 +10,27 @@
     "preview": "vite preview"
   },
   "dependencies": {
+    "axios": "^1.11.0",
+    "lucide-react": "^0.542.0",
     "react": "^19.1.1",
-    "react-dom": "^19.1.1"
+    "react-dom": "^19.1.1",
+    "react-markdown": "^10.1.0",
+    "recharts": "^3.1.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.33.0",
+    "@tailwindcss/line-clamp": "^0.4.4",
+    "@tailwindcss/typography": "^0.5.16",
     "@types/react": "^19.1.10",
     "@types/react-dom": "^19.1.7",
     "@vitejs/plugin-react": "^5.0.0",
+    "autoprefixer": "^10.4.21",
     "eslint": "^9.33.0",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-react-refresh": "^0.4.20",
     "globals": "^16.3.0",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^3.4.0",
     "vite": "^7.1.2"
   }
 }

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

frontend/src/App.jsx

@@ -1,35 +1,113 @@
-import { useState } from 'react'
-import reactLogo from './assets/react.svg'
-import viteLogo from '/vite.svg'
-import './App.css'
+import React, { useState, useEffect } from 'react';
+import Header from './components/Header';
+import JobForm from './components/JobForm';
+import JobStatusCard from './components/JobStatusCard';
+import ResultsDisplay from './components/ResultsDisplay';
+import LoadingSkeleton from './components/LoadingSkeleton';
+import HistoryPanel from './components/HistoryPanel';
+import { createJob, getJob } from './services/api';
+import { XCircle } from 'lucide-react'; 
 
 function App() {
-  const [count, setCount] = useState(0)
+  const [job, setJob] = useState(null);
+  const [isLoading, setIsLoading] = useState(false); 
+  const [isPolling, setIsPolling] = useState(false); 
+  const [error, setError] = useState(null);
+
+  const handleAnalysisRequest = async (ticker) => {
+    setIsLoading(true);
+    setIsPolling(true);
+    setError(null);
+    setJob(null);
+    try {
+      const response = await createJob(ticker);
+      setJob(response.data);
+    } catch (err) {
+      setError('Failed to create job. Please check the API server and try again.');
+      setIsLoading(false);
+      setIsPolling(false);
+    }
+  };
+
+  const handleSelectHistoryJob = (historyJob) => {
+    setIsLoading(false);
+    setIsPolling(false);
+    setError(null);
+    setJob(historyJob);
+  }
+
+  useEffect(() => {
+    if (!job?.id || !isPolling) return;
+
+    if (job.status !== 'PENDING') {
+      setIsLoading(false);
+    }
+
+    const intervalId = setInterval(async () => {
+      try {
+        const response = await getJob(job.id);
+        const updatedJob = response.data;
+        setJob(updatedJob);
+
+        if (updatedJob.status === 'SUCCESS' || updatedJob.status === 'FAILED') {
+          clearInterval(intervalId);
+          setIsPolling(false);
+        }
+      } catch (err) {
+        setError('Failed to poll job status.');
+        clearInterval(intervalId);
+        setIsPolling(false);
+      }
+    }, 3000);
+
+    return () => clearInterval(intervalId);
+  }, [job, isPolling]);
 
   return (
-    <>
-      <div>
-        <a href="https://vite.dev" target="_blank">
-          <img src={viteLogo} className="logo" alt="Vite logo" />
-        </a>
-        <a href="https://react.dev" target="_blank">
-          <img src={reactLogo} className="logo react" alt="React logo" />
-        </a>
-      </div>
-      <h1>Vite + React</h1>
-      <div className="card">
-        <button onClick={() => setCount((count) => count + 1)}>
-          count is {count}
-        </button>
-        <p>
-          Edit <code>src/App.jsx</code> and save to test HMR
-        </p>
-      </div>
-      <p className="read-the-docs">
-        Click on the Vite and React logos to learn more
-      </p>
-    </>
-  )
+    <div className="min-h-screen bg-gray-900 text-white font-sans">
+      <Header />
+      <HistoryPanel onSelectJob={handleSelectHistoryJob} />
+      
+      <main className="container mx-auto p-4 md:p-8">
+        <div className="max-w-4xl mx-auto">
+          <p className="text-lg text-gray-400 mb-8 text-center">
+            Enter an Indian stock ticker to receive a comprehensive, AI-powered analysis.
+          </p>
+          
+          <JobForm onAnalyze={handleAnalysisRequest} isLoading={isLoading || isPolling} />
+          
+          {error && <div className="my-6 p-4 bg-red-900/50 rounded-lg text-red-300 text-center">{error}</div>}
+          
+          {isLoading && !job && <LoadingSkeleton />}
+          
+          {job && !isLoading && <JobStatusCard job={job} />}
+
+          {job?.status === 'SUCCESS' && job.result && (
+            <ResultsDisplay result={job.result} />
+          )}
+
+          {job?.status === 'FAILED' && job.result?.error && (
+             <div className="mt-8 p-6 bg-gray-800/30 border border-red-500/30 rounded-lg text-center animate-fade-in">
+               <XCircle className="w-16 h-16 text-red-400 mx-auto mb-4" />
+               <h2 className="text-2xl font-bold text-red-300 mb-2">Analysis Failed</h2>
+               <p className="text-gray-400 max-w-lg mx-auto">
+                 We couldn't complete the analysis for <strong className="text-white">{job.ticker}</strong>.
+                 This usually means the stock symbol is incorrect or not listed.
+               </p>
+               <p className="text-xs text-gray-500 mt-4">Please double-check the ticker (e.g., RELIANCE.NS) and try again.</p>
+               
+               <details className="mt-6 text-left w-full max-w-lg mx-auto">
+                 <summary className="cursor-pointer text-xs text-gray-500 hover:text-gray-400 focus:outline-none">Show technical details</summary>
+                 <pre className="mt-2 bg-gray-900 p-4 rounded-md text-gray-400 text-xs whitespace-pre-wrap font-mono">
+                   {job.result.error}
+                 </pre>
+               </details>
+             </div>
+          )}
+        </div>
+      </main>
+    </div>
+  );
 }
 
-export default App
+export default App;

frontend/src/components/Header.jsx

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Bot } from 'lucide-react'; // Using a cool icon
+
+function Header() {
+  return (
+    <header className="py-6 border-b border-gray-700">
+      <div className="container mx-auto flex items-center justify-center space-x-3">
+        <Bot className="w-8 h-8 text-green-400" />
+        <h1 className="text-3xl font-bold tracking-tight text-gray-100">
+          Quantitative Analysis Platform
+        </h1>
+      </div>
+    </header>
+  );
+}
+
+export default Header;

frontend/src/components/HistoricalChart.jsx

@@ -0,0 +1,67 @@
+import React, { useState, useEffect } from 'react';
+import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer } from 'recharts';
+import axios from 'axios';
+
+// A more reliable public CORS proxy
+const PROXY_URL = 'https://api.allorigins.win/raw?url=';
+
+const fetchHistoricalData = async (ticker) => {
+    const yahooUrl = `https://query1.finance.yahoo.com/v8/finance/chart/${ticker}?range=100d&interval=1d`;
+    const encodedUrl = encodeURIComponent(yahooUrl);
+    
+    try {
+        const response = await axios.get(PROXY_URL + encodedUrl);
+        const data = response.data.chart.result[0];
+        const timestamps = data.timestamp;
+        const prices = data.indicators.quote[0].close;
+
+        // Filter out any null price points which can crash the chart
+        return timestamps
+            .map((ts, i) => ({
+                date: new Date(ts * 1000).toLocaleDateString('en-IN', {day: 'numeric', month: 'short'}),
+                price: prices[i] ? prices[i].toFixed(2) : null,
+            }))
+            .filter(point => point.price !== null);
+
+    } catch (error) {
+        console.error("Failed to fetch historical data for chart:", error);
+        return [];
+    }
+};
+
+function HistoricalChart({ ticker }) {
+    const [data, setData] = useState([]);
+    const [loading, setLoading] = useState(true);
+
+    useEffect(() => {
+        if (ticker) {
+            setLoading(true);
+            fetchHistoricalData(ticker).then(chartData => {
+                setData(chartData);
+                setLoading(false);
+            });
+        }
+    }, [ticker]);
+
+    if (loading) return <div className="h-[300px] flex items-center justify-center"><p className="text-gray-400">Loading Chart Data...</p></div>;
+    if (data.length === 0) return <div className="h-[300px] flex items-center justify-center"><p className="text-gray-400">Could not load chart data.</p></div>;
+
+    return (
+        <div style={{ width: '100%', height: 300 }}>
+            <ResponsiveContainer>
+                <LineChart data={data} margin={{ top: 5, right: 10, left: -20, bottom: 5 }}>
+                    <CartesianGrid strokeDasharray="3 3" stroke="rgba(255, 255, 255, 0.1)" />
+                    <XAxis dataKey="date" stroke="#9CA3AF" tick={{ fontSize: 12 }} />
+                    <YAxis stroke="#9CA3AF" tick={{ fontSize: 12 }} domain={['auto', 'auto']} />
+                    <Tooltip 
+                        contentStyle={{ backgroundColor: '#1F2937', border: '1px solid #374151' }}
+                        labelStyle={{ color: '#F3F4F6' }}
+                    />
+                    <Line type="monotone" dataKey="price" stroke="#34D399" strokeWidth={2} name="Close Price" dot={false} />
+                </LineChart>
+            </ResponsiveContainer>
+        </div>
+    );
+}
+
+export default HistoricalChart;

frontend/src/components/HistoryPanel.jsx

@@ -0,0 +1,86 @@
+import React, { useState, useEffect } from 'react';
+import { getJobsHistory } from '../services/api';
+import { History, LoaderCircle } from 'lucide-react';
+
+function HistoryPanel({ onSelectJob }) {
+  const [history, setHistory] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isOpen, setIsOpen] = useState(false);
+
+  const fetchHistory = () => {
+    setIsLoading(true);
+    getJobsHistory()
+      .then(response => {
+        // Filter for only completed jobs to make the list cleaner
+        setHistory(response.data.filter(job => job.status === 'SUCCESS' || job.status === 'FAILED'));
+      })
+      .catch(error => console.error("Failed to fetch history:", error))
+      .finally(() => setIsLoading(false));
+  };
+
+  // When the panel opens, fetch the history
+  const togglePanel = () => {
+    const newIsOpen = !isOpen;
+    setIsOpen(newIsOpen);
+    if (newIsOpen) {
+      fetchHistory();
+    }
+  };
+
+  const handleSelect = (job) => {
+    onSelectJob(job);
+    setIsOpen(false);
+  }
+
+  return (
+    <>
+      <button 
+        onClick={togglePanel}
+        className="fixed bottom-6 right-6 bg-green-600 hover:bg-green-700 text-white p-4 rounded-full shadow-lg z-50 transition-transform hover:scale-110 focus:outline-none focus:ring-2 focus:ring-green-400"
+        aria-label="Toggle analysis history"
+      >
+        <History className="w-8 h-8" />
+      </button>
+
+      {/* Overlay to close panel when clicking outside */}
+      {isOpen && <div onClick={() => setIsOpen(false)} className="fixed inset-0 bg-black/50 z-30 transition-opacity"></div>}
+
+      <div className={`fixed top-0 right-0 h-full bg-gray-900 border-l border-gray-700 shadow-2xl z-40 transition-transform duration-500 ease-in-out ${isOpen ? 'translate-x-0' : 'translate-x-full'} w-full md:w-96`}>
+        <div className="p-4 border-b border-gray-700 flex justify-between items-center">
+          <h2 className="text-xl font-bold">Analysis History</h2>
+          <button onClick={() => setIsOpen(false)} className="text-gray-400 hover:text-white text-3xl">&times;</button>
+        </div>
+        <div className="p-4 overflow-y-auto h-[calc(100%-4rem)]">
+          {isLoading ? (
+            <div className="flex justify-center items-center h-full pt-20">
+              <LoaderCircle className="w-8 h-8 animate-spin text-green-400" />
+            </div>
+          ) : history.length === 0 ? (
+            <div className="text-center pt-20">
+              <p className="text-gray-500">No past analyses found.</p>
+              <p className="text-xs text-gray-600 mt-2">Complete an analysis to see it here.</p>
+            </div>
+          ) : (
+            <ul className="space-y-3">
+              {history.map(job => (
+                <li 
+                  key={job.id} 
+                  onClick={() => handleSelect(job)}
+                  className="p-3 bg-gray-800 rounded-md cursor-pointer hover:bg-green-800/50 border border-transparent hover:border-green-400/50 transition-all"
+                >
+                  <p className="font-bold text-white">{job.ticker}</p>
+                  <div className="flex justify-between text-xs text-gray-400 mt-1">
+                    <span>{new Date(job.created_at).toLocaleString('en-IN', { dateStyle: 'medium', timeStyle: 'short' })}</span>
+                    <span className={`font-semibold px-2 py-0.5 rounded-full ${job.status === 'SUCCESS' ? 'bg-green-900/50 text-green-300' : 'bg-red-900/50 text-red-300'}`}>{job.status}</span>
+                  </div>
+                </li>
+              ))}
+            </ul>
+          )}
+        </div>
+      </div>
+    </>
+  );
+}
+
+export default HistoryPanel;

frontend/src/components/JobForm.jsx

@@ -0,0 +1,44 @@
+import React, { useState } from 'react';
+import { Search, LoaderCircle } from 'lucide-react';
+
+// The component now receives 'onAnalyze' and 'isLoading' as props
+function JobForm({ onAnalyze, isLoading }) {
+  const [ticker, setTicker] = useState('');
+
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    if (!ticker.trim() || isLoading) return;
+    onAnalyze(ticker); // Call the function passed down from App.jsx
+  };
+
+  return (
+    <form onSubmit={handleSubmit} className="mb-12">
+      <div className="flex items-center bg-gray-800 border-2 border-gray-600 rounded-lg overflow-hidden focus-within:border-green-400 transition-colors duration-300">
+        <span className="pl-4 text-gray-400">
+          <Search className="w-6 h-6" />
+        </span>
+        <input
+          type="text"
+          value={ticker}
+          onChange={(e) => setTicker(e.target.value.toUpperCase())}
+          placeholder="e.g., RELIANCE.NS"
+          className="w-full p-4 bg-transparent text-lg text-gray-200 placeholder-gray-500 focus:outline-none"
+          disabled={isLoading}
+        />
+        <button
+          type="submit"
+          className="bg-green-600 hover:bg-green-700 text-white font-bold py-4 px-6 transition-colors duration-300 disabled:bg-gray-500 disabled:cursor-not-allowed"
+          disabled={isLoading}
+        >
+          {isLoading ? (
+            <LoaderCircle className="animate-spin w-6 h-6" />
+          ) : (
+            'Analyze'
+          )}
+        </button>
+      </div>
+    </form>
+  );
+}
+
+export default JobForm;

frontend/src/components/JobStatusCard.jsx

@@ -0,0 +1,66 @@
+import React from 'react';
+import { LoaderCircle, CheckCircle2, XCircle, FileClock, Database, Search, Bot } from 'lucide-react';
+
+function JobStatusCard({ job }) {
+  const getStatusInfo = (status) => {
+    // This map now perfectly matches the statuses set in your main_task.py
+    const statusMap = {
+      'PENDING': {
+        icon: <FileClock className="w-8 h-8 text-yellow-400" />,
+        text: 'Your analysis is in the queue.',
+        bgColor: 'bg-yellow-900/50 border-yellow-400/30',
+      },
+      'DATA_FETCHING': {
+        icon: <Database className="w-8 h-8 text-blue-400 animate-pulse" />,
+        text: 'Agent 1: Data Agent is fetching fundamentals...',
+        bgColor: 'bg-blue-900/50 border-blue-400/30',
+      },
+      'INTELLIGENCE_GATHERING': {
+        icon: <Search className="w-8 h-8 text-blue-400 animate-pulse" />,
+        text: 'Agent 2: Intelligence Agent is scanning news...',
+        bgColor: 'bg-blue-900/50 border-blue-400/30',
+      },
+      'ANALYZING': {
+        icon: <Bot className="w-8 h-8 text-blue-400 animate-spin" />,
+        text: 'Agent 3: Analyst Agent is generating a report with Gemini...',
+        bgColor: 'bg-blue-900/50 border-blue-400/30',
+      },
+      'SUCCESS': {
+        icon: <CheckCircle2 className="w-8 h-8 text-green-400" />,
+        text: 'All agents have completed their tasks!',
+        bgColor: 'bg-green-900/50 border-green-400/30',
+      },
+      'FAILED': {
+        icon: <XCircle className="w-8 h-8 text-red-400" />,
+        text: `Analysis failed. See error below.`,
+        bgColor: 'bg-red-900/50 border-red-400/30',
+      }
+    };
+    
+    return statusMap[status] || {
+        icon: <FileClock className="w-8 h-8 text-gray-400" />,
+        text: 'Waiting for status...',
+        bgColor: 'bg-gray-800 border-gray-600',
+    };
+  };
+
+  const statusInfo = getStatusInfo(job.status);
+
+  return (
+    <div className="my-8">
+      <div className={`p-6 rounded-lg border flex items-center space-x-4 transition-all duration-500 ${statusInfo.bgColor}`}>
+        <div className="flex-shrink-0">
+          {statusInfo.icon}
+        </div>
+        <div>
+          <p className="font-bold text-lg text-gray-200">
+            Analysis for {job.ticker}
+          </p>
+          <p className="text-gray-400">{statusInfo.text}</p>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default JobStatusCard;

frontend/src/components/LoadingSkeleton.jsx

@@ -0,0 +1,46 @@
+import React from 'react';
+
+// A simple helper for the pulsing effect
+const SkeletonBlock = ({ className }) => (
+  <div className={`bg-gray-700 rounded-md animate-pulse ${className}`} />
+);
+
+function LoadingSkeleton() {
+  return (
+    <div className="mt-8 p-6 bg-gray-800/50 border border-gray-700 rounded-lg">
+      {/* Header Skeleton */}
+      <div className="mb-6 pb-6 border-b border-gray-700">
+        <SkeletonBlock className="h-12 w-3/4 mb-3" />
+        <SkeletonBlock className="h-6 w-1/2" />
+      </div>
+
+      {/* Key Metrics Skeleton */}
+      <div className="grid grid-cols-2 md:grid-cols-5 gap-4 mb-10">
+        <SkeletonBlock className="h-20" />
+        <SkeletonBlock className="h-20" />
+        <SkeletonBlock className="h-20" />
+        <SkeletonBlock className="h-20" />
+        <SkeletonBlock className="h-20" />
+      </div>
+
+      {/* Chart Skeleton */}
+      <div className="mb-12 bg-gray-900/40 p-6 rounded-xl">
+        <SkeletonBlock className="h-8 w-1/3 mb-4" />
+        <SkeletonBlock className="h-72 w-full" />
+      </div>
+
+      {/* AI Report Skeleton */}
+      <div className="mb-12">
+        <SkeletonBlock className="h-8 w-1/3 mb-4" />
+        <div className="p-6 bg-gray-900/40 rounded-xl space-y-4">
+          <SkeletonBlock className="h-6 w-full" />
+          <SkeletonBlock className="h-6 w-5/6" />
+          <SkeletonBlock className="h-6 w-full" />
+          <SkeletonBlock className="h-6 w-3/4" />
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default LoadingSkeleton;

frontend/src/components/PredictionChart.jsx

@@ -0,0 +1,36 @@
+import React from 'react';
+import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer, Area } from 'recharts';
+
+function PredictionChart({ data }) {
+  if (!data || data.length === 0) return null;
+
+  // Format the date for the X-axis
+  const formatXAxis = (tickItem) => {
+    return new Date(tickItem).toLocaleDateString('en-IN', { month: 'short', day: 'numeric' });
+  };
+  
+  return (
+    <div style={{ width: '100%', height: 400 }}>
+      <ResponsiveContainer>
+        <LineChart data={data} margin={{ top: 5, right: 20, left: -10, bottom: 5 }}>
+          <CartesianGrid strokeDasharray="3 3" stroke="#4A5568" />
+          <XAxis dataKey="ds" tickFormatter={formatXAxis} stroke="#A0AEC0" />
+          <YAxis stroke="#A0AEC0" domain={['dataMin - 5', 'dataMax + 5']} />
+          <Tooltip 
+            contentStyle={{ backgroundColor: '#1A202C', border: '1px solid #4A5568' }}
+            labelFormatter={(label) => new Date(label).toLocaleDateString('en-IN')}
+          />
+          <Legend />
+          {/* Confidence Interval Area */}
+          <Area type="monotone" dataKey="yhat_upper" fill="#2F855A" stroke="#2F855A" fillOpacity={0.1} name="Upper Confidence" dot={false} />
+          <Area type="monotone" dataKey="yhat_lower" fill="#2F855A" stroke="#2F855A" fillOpacity={0.1} name="Lower Confidence" dot={false} />
+          
+          {/* Forecast Line */}
+          <Line type="monotone" dataKey="yhat" stroke="#48BB78" strokeWidth={2} name="Forecast" dot={false} />
+        </LineChart>
+      </ResponsiveContainer>
+    </div>
+  );
+}
+
+export default PredictionChart;