stock-market-playground

FinRobot Scripts: Standalone Financial Analysis and Trading Tools

This repository contains a collection of standalone Python scripts for financial analysis, stock forecasting, trading strategy development, and optimization. These scripts are inspired by agent-based workflows and combine data sourcing, LLM-assisted analysis, and backtesting tools.

The scripts focus on stock market data for companies like Tesla (TSLA), Apple (AAPL), Microsoft (MSFT), etc., and use libraries for data sourcing (YFinance, FinnHub), visualization (matplotlib, mplfinance), LoRA and LLMs for forecasts and strategy suggestions, and backtesting libraries.

Key Features

• Fetch stock data and news from APIs.
• Generate charts, analyses, and forecasts using LLMs.
• Optimize trading strategies iteratively.
• Produce PDF reports with summaries, plots, and metrics.
• Integration options with local LLMs (e.g., via Ollama) for some scripts.

Table of Contents

• Requirements
• Installation
• API Keys
• Scripts Overview
• Web App (React front-end)
• Usage Examples
• Contributing
• License

Requirements

• Python 3.8+ (tested on 3.12 for some scripts)
• Node.js 18+ and npm (for the React web app)
• GPU recommended for LLM inference (e.g., with CUDA for Torch).
• Libraries: See the requirements.txt file (generate it via pip freeze > requirements.txt after installing dependencies).

Core dependencies include:

• torch (for LLM inference)
• transformers and peft (for Hugging Face models and LoRA)
• pandas, numpy, matplotlib, mplfinance (data handling and plotting)
• fpdf (PDF generation)
• backtrader (backtesting in some scripts)
• yfinance, finnhub-python (data sources; note: finrobot is a custom module in some scripts—see notes below)
• autogen (for the Ollama-based script)
• requests, PyPDF2 (for PDF handling in analysis scripts)

Note on finrobot: Some scripts reference finrobot.utils and finrobot.data_source. This is a custom helper library for API key registration and data fetching. If not available, you can replace those helpers with direct calls to yfinance or finnhub-python.

For LLM models:

• Download models from Hugging Face (e.g., meta-llama/Llama-2-7b-chat-hf, FinGPT/fingpt-forecaster_dow30_llama2-7b_lora).
• Ensure sufficient VRAM (at least 8GB for Llama-2).

For the Ollama script:

• Ollama server running locally with a model like "qwen3" (setup: https://ollama.ai/).

Installation

1. Clone the repository:

git clone https://github.com/overcrash66/stock-market-playground.git
cd stock-market-playground

2. Create a virtual environment (optional but recommended):

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

3. Install Python dependencies:

pip install -r requirements.txt

4. Node / Web App setup (see "Web App" section below for details):

• Install dependencies and run the React front-end from the Web-App/Web-App directory.

5. Download models: The scripts will auto-download from Hugging Face on first run, but ensure you have a Hugging Face token if required (e.g., for gated models like Llama-2).

API Keys

Many scripts fetch data from FinnHub or YFinance. For FinnHub:

• Create a config_api_keys JSON file with your keys (e.g., {"FINNHUB": "your_api_key"}).
• Some scripts call register_keys_from_json("config_api_keys").

YFinance is free but rate-limited.

Scripts Overview

Each script is standalone and can be run directly (e.g., python script_name.py). They output to directories like stock_analysis, annual_report, etc., with PDFs, plots, and data.

1. lmm_agent_mplfinance.py
   Fetches stock data and news for Tesla (TSLA), plots a candlestick chart with mplfinance, analyzes fluctuations using a LoRA-enhanced Llama model, and generates a PDF report.

• Customizable: Edit company, ticker, dates.
• Outputs: stock_analysis_report.pdf, chart.png.

2. AllInOne-FinGPT-Forecaster.py
   Fetches profile, news, financials, and stock data for Apple (AAPL), summarizes, uses FinGPT LoRA for forecasting stock trends, plots close prices and volume, and generates a PDF report.

• Customizable: Change company, ticker.
• Outputs: apple_stock_report.pdf, plots.

3. AllInOne-FinGPT-Company-analysis.py
   Downloads and analyzes a company's annual report PDF (e.g., Microsoft FY2024), summarizes chunks with Llama, generates a full report, fetches additional data, forecasts stock with LoRA (optional), and outputs a combined PDF.

• Robust: Handles GPU/CPU fallback, LoRA optional.
• Customizable: Env vars for COMPANY, FYEAR, TICKER, PDF_URL.
• Outputs: {company}_annual_report_{fyear}.pdf, plots.

4. trade_strategist.py
   Generates a Backtrader strategy for Microsoft (MSFT) using Llama, backtests it, optimizes iteratively with LoRA based on results (e.g., returns vs. buy-and-hold), and produces a PDF report with code and plots.

• Customizable: Edit company, dates, ticker.
• Outputs: trade_strategy_report.pdf, strategy.py, backtest_plot.png.

5. opt_smacross.py
   Optimizes SMA Crossover strategy parameters for Microsoft (MSFT) by fetching data, suggesting params with Llama, backtesting with Backtrader, analyzing with LoRA, iterating, and generating a PDF summary.

• Customizable: Edit company, dates, ticker.
• Outputs: sma_optimization_report.pdf, charts and backtest plots per iteration.

6. ollama stock chart.py
   Uses AutoGen agents with a local Ollama model (qwen3) to plot Apple stock price changes for 2023 using yfinance, and saves the chart.

• Customizable: Edit year, company.
• Outputs: Chart file in ../result code plot (relative path; adjust as needed).
• Requires Ollama running.

Web App (React front-end)

This repository includes a React-based front-end located at Web-App/Web-App. The Web App is a separate single-page application built with Create React App that provides a user-friendly interface to explore stock data, view charts, and preview reports generated by the Python scripts.

What you'll find here:

• Location: Web-App/Web-App (run commands from that directory).
• Tech stack: Create React App, React, optionally other libraries (check package.json for exact dependencies).
• Purpose: Provide an interactive UI to search tickers, display historical price charts, and surface analysis outputs (plots/PDFs) produced by the scripts.

Quick start (Web App):

1. Change into the web app directory:

cd Web-App/Web-App

2. Install Node dependencies:

npm install

3. Start the development server:

npm start

Open http://localhost:3000 in a browser.

Build for production:

npm run build

The production-ready files will be in Web-App/Web-App/build and can be served by any static hosting (Netlify, Vercel, GitHub Pages, S3, etc.).

Environment variables and API integration:

• If the front-end needs to call a backend or local API, create a .env file in Web-App/Web-App with keys prefixed with REACT_APP_ (example: REACT_APP_API_BASE_URL=http://localhost:8000).
• Restart the dev server after changing .env files.

Suggested backend integration

• To surface outputs from the Python scripts in the UI, expose a small HTTP API (Flask or FastAPI recommended) that:
  • serves generated images/plots at endpoints like /plots/{ticker}.png
  • serves PDFs at /reports/{report_name}.pdf
  • provides CSV/JSON data endpoints for charts such as /api/prices?ticker=TSLA&start=2024-01-01
• Set REACT_APP_API_BASE_URL to point to that backend and call it from the React app.
• Keep secrets (API keys) on the server side and never commit them to the repo.

Structure overview (common CRA layout):

• src/ — main React source files
• src/components/ — reusable components
• src/App.js — app root
• public/ — static assets and index.html

Notes and suggestions:

• The Web App README at Web-App/Web-App/README.md contains the default Create React App guidance — check it for standard CRA commands.
• Connect the Python scripts to the web app by exposing a backend API (Flask/FastAPI) that serves generated plots, CSVs or PDFs; then set REACT_APP_API_BASE_URL to point to that API.
• If adding sensitive keys for external APIs, keep them on the server (never commit secrets to the repo) and only expose non-sensitive endpoints to the front-end.

Usage Examples

• Run a script:

python lmm_agent_mplfinance.py

• For environment variables (e.g., in AllInOne-FinGPT-Company-analysis.py):

export COMPANY="Tesla"
export TICKER="TSLA"
export PDF_URL="https://example.com/tesla-annual-report.pdf"
python AllInOne-FinGPT-Compagny-analysis.py

• Run the Web App frontend (from Web-App/Web-App):

npm install
npm start

• Outputs are saved in script-specific directories (e.g., stock_analysis/).

Warnings:

• LLM outputs can vary; scripts include fallbacks for invalid code/params.
• API rate limits: Use sparingly.
• Rename files if conflicts (e.g., avoid shadowing libraries like mplfinance).
• Current date in scripts may be hardcoded or fetched; adjust for historical analysis.

Contributing

Pull requests welcome! Add new scripts, improve the web UI, fix bugs, or improve documentation. For changes to the Web App, open PRs that include build/test steps and any API contract changes.

If you'd like me to prepare a focused PR just for README updates (or also to add a small example backend integration), tell me which branch name you'd like or I'll suggest one and include a clear commit message.

License

MIT License. See LICENSE for details.

---

If you find this repo useful, star it or share your improvements!