---
title: StrategyGenerator
app_file: app.py
sdk: gradio
sdk_version: 5.47.2
---
# Financial Strategy Generator

A Gradio web application that generates Python trading strategies from natural language descriptions using Large Language Models (LLMs). The generated strategies can be instantly backtested using the Backtrader library with real market data from Yahoo Finance.

## Overview

This application allows you to:
- **Describe trading strategies in plain English** (e.g., "Buy when 10-day SMA crosses above 100-day SMA")
- **Generate Python code automatically** using state-of-the-art LLMs
- **Backtest strategies immediately** in the GUI with configurable parameters
- **Visualize results** with interactive charts and detailed transaction logs
- **Export data** for further analysis

## Key Features

- 🤖 **Multi-LLM Support**: Choose from GPT, Claude, Deepseek, Gemini, or Grok4
- 📊 **Financial Indicators**: Supports SMA, MACD, RSI, ATR, and more via Backtrader
- 📈 **Interactive Backtesting**: Real-time strategy testing with Yahoo Finance data
- 💾 **Data Caching**: Automatic caching to avoid redundant downloads
- 📉 **Visual Analytics**: Charts, transaction tables, and trade performance metrics
- ⚙️ **Configurable Parameters**: Customize capital, commission, slippage, and more
- 🎯 **Multiple Timeframes**: Support for 1m, 5m, 15m, 1h, 1d intervals
- 📥 **Export Capabilities**: Download generated code and CSV reports

## Requirements

- **Python 3.12**
- Dependencies listed in `requirements.txt`.

## Installation & Setup

### 1. Clone the Repository

```bash
git clone <repository-url>
cd LLM-fintech
```

### 2. Install Dependencies

```bash
pip install -r requirements.txt
```

### 3. Environment Variables

Create a `.env` file in the project root with your LLM API keys:

```env
OPENAI_API_KEY=your_openai_key_here
ANTHROPIC_API_KEY=your_anthropic_key_here
DEEPSEEK_API_KEY=your_deepseek_key_here
GOOGLE_API_KEY=your_google_key_here
XAI_API_KEY=your_grok_key_here

# Optional: FMP key for extracting date
FMP_API_KEY=your_fmp_key_here
# Optional: For HuggingFace local mode
HF_TOKEN=your_huggingface_token_here

# Optional: Override default models (see config/var_dev.yaml for defaults)
OPENAI_MODEL=gpt-4
CLAUDE_MODEL=claude-sonnet-4-20250514
DEEPSEEK_MODEL=deepseek-reasoner
GEMINI_MODEL=gemini-2.5-flash
GROK4_MODEL=grok-4-fast-reasoning
```

### 4. Configuration

The application uses `config/var_dev.yaml` for default settings:
- Market/ticker mappings (e.g., "S&P 500 ETF" → "SPY")
- Default LLM model names
- Backtesting parameters (initial capital, commission, slippage)
- Data intervals and periods

You can modify this file to customize defaults without changing code.

## Running Locally

### Start the Application

```bash
python app.py
```

The Gradio interface will automatically open in your default browser. The app runs on `http://127.0.0.1:7860` by default.

### Using the Interface

1. **Generate Strategy**: 
   - Select your preferred LLM model from the dropdown
   - Enter a natural language description of your trading strategy
   - Click "Generate Strategy" to create Python code

2. **Configure Backtesting**:
   - Choose a stock/ETF or enter a custom ticker symbol
   - Set initial capital, commission, and slippage
   - Select date range and data interval
   - Optionally enable adjusted prices (for dividends/splits)

3. **Run Backtest**:
   - Click "Run Python Code" to execute the strategy
   - View results in the Python result panel
   - Check the "Charts" tab for visualizations
   - Review "Transactions" and "Trades" tabs for detailed logs

4. **Export Results**:
   - Download generated strategy code as a `.py` file
   - Export transaction and trade data as CSV files

## Gradio Deployment

To deploy this application to Gradio's hosting service:

### 1. Install `uv`

```bash
# On macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# On Windows
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Or via pip
pip install uv
```

### 2. Deploy

```bash
uv gradio deploy
```

This command will:
- Package your application
- Upload it to Gradio's servers
- Provide a public URL for your deployed app

**Note**: Make sure your `.env` file is configured properly, or set environment variables in your deployment environment for API keys.

For more deployment options and configurations, refer to [Gradio Deployment Documentation](https://www.gradio.app/guides/deploying-your-app).

## Project Structure

```
LLM-fintech/
├── app.py                 # Main Gradio application interface
├── strategy_generator.py  # LLM integration and strategy code generation
├── bt_utils.py           # Backtesting engine, data fetching, and plotting
├── bt_strategies.py      # Example strategy classes (reference implementations)
├── bt_testing.py         # Standalone backtesting script (for testing)
├── utils.py              # Helper functions (validation, file operations)
├── config/
│   └── var_dev.yaml      # Configuration file (markets, models, defaults)
├── data_cache/           # Cached Yahoo Finance data (auto-generated)
├── requirements.txt      # Python dependencies
└── README.md            # This file
```

## Configuration Details

### Market/Ticker Mappings

The `config/var_dev.yaml` file contains mappings between friendly names and ticker symbols. You can:
- Use predefined markets from the dropdown (e.g., "S&P 500 ETF")
- Enter any valid Yahoo Finance ticker symbol directly
- Add custom mappings by editing the YAML file

### Supported Data Intervals

- **Intraday**: `1m`, `2m`, `5m`, `15m`, `30m`, `1h`
- **Daily**: `1d`

Note: Intraday data has limitations on historical range (Yahoo Finance restrictions).

### Backtesting Parameters

- **Initial Capital**: Starting portfolio value (default: $10,000)
- **Commission**: Per-share trading commission (default: $0.005)
- **Slippage**: Percentage of price applied as slippage (default: 0.01%)
- **Adjusted Prices**: Use dividend/split-adjusted prices (recommended: enabled)

## Supported Financial Indicators

The generated strategies can use any Backtrader indicator, including:
- **Moving Averages**: SMA, EMA, WMA
- **Momentum**: RSI, Stochastic, MACD
- **Volatility**: ATR, Bollinger Bands
- **Volume**: Volume indicators
- **Custom Indicators**: Any Backtrader-compatible indicator

Example strategy descriptions:
- "Go long when RSI crosses above 30 and 10-day SMA is above 50-day SMA"
- "Buy when MACD line crosses above signal line, exit when it crosses below"
- "Use ATR for position sizing, enter on golden cross with RSI confirmation"

## Data Caching

The application automatically caches downloaded market data in the `data_cache/` directory. This:
- Speeds up subsequent backtests
- Reduces API calls to Yahoo Finance
- Caches are keyed by ticker, interval, date range, and adjustment settings

Cache files are automatically managed and will be re-downloaded if parameters change.

## Troubleshooting

### Common Issues

1. **API Key Errors**: Ensure all required API keys are set in your `.env` file
2. **No Data Available**: Check that your ticker symbol is valid and date range is appropriate
3. **Code Generation Fails**: Try a different LLM model or refine your strategy description
4. **Chart Not Displaying**: Ensure matplotlib backend is set correctly (handled automatically)

### Browser Compatibility

The Gradio interface works best on modern browsers (Chrome, Firefox, Safari, Edge). If charts don't display, try:
- Clearing browser cache
- Using a different browser
- Checking browser console for errors

## Notes

- Generated code follows Backtrader's strategy pattern and best practices
- Strategies must inherit from `bt.Strategy` and implement `__init__` and `next()` methods
- The app automatically wraps generated code with backtesting execution logic
- Data is fetched from Yahoo Finance with automatic handling of market hours and holidays

## Version
0.0.2: added FMP extraction, replay mode and database reading for intraday

0.0.1: First working version


## License
Needs to be done

## Contributing
Next Steps