ai-trader-station

AI-powered trading workstation built on PySide6 and MetaTrader 5.

Bill Williams signal cascade, MCP protocol surface, AI price forecasting on RunPod serverless GPU. Built for real trading — runs anywhere Python and MetaTrader 5 are installed.

ChaosPanel — Fib-Based Order Execution

One-click order execution. Auto-detects BUY/SELL from fib direction, risk%-based lot sizing, BUY STOP / SELL STOP / market orders with pre-send price validation. Fibonacci levels drawn on chart, risk/reward calculated live.

BW Screener — Multi-Symbol Signal Scan

Scan any number of symbols across all timeframes (M1 to MN1) for Bill Williams setups. Color-coded AO signals (Cross, Saucer, Twin Peaks), MFI analysis (Green, Fade, Fake, Squat), fractal markers — all updating in real time with auto-refresh.

AO Chart — Interactive Analysis

Drill into any symbol. Alligator overlay (Jaw/Teeth/Lips), Awesome Oscillator histogram, fractal arrows, signal annotations. BW status bar shows current AO state, MFI reading, and Alligator alignment at a glance.

AI Chat — Natural Language Trading

DeepSeek + Qwen3-VL powered chat with MCP tool use. Ask questions about market data, run analysis, execute trades — all through natural language. Full MCP protocol surface with schema-validated tool calls.

Trade Management — Live Positions & Orders

Monitor open positions and pending orders in real time. BUY STOP orders placed by the bot show source, SL/TP levels, and one-click cancel. P&L tracking across all positions.

Features

• Bill Williams Signal Cascade — Alligator, AO, Fractals, Gator, Zone Trading, Twin Peaks divergence. Multi-timeframe confirmation: fractal trigger → AO confirm → higher-TF filter.

• ChaosPanel — Order execution with auto BUY/SELL detection, risk%-based lot sizing, BUY/SELL STOP + market orders, filling-mode handling.

• AO Screener — Scan multiple symbols for BW setups across all timeframes.

• Kronos AI Forecaster — 102M parameter price prediction model on RunPod serverless. Lot-sizing advisor: agrees with signal → x1.5, disagrees → x0.5, neutral → x1.0.

• MCP Protocol Surface — Model Context Protocol tool interface for agentic AI access to all trading capabilities. Thread-safe Qt bridge.

• AI Chat — DeepSeek/Qwen3-VL with MCP tool use for natural language trading.

• Plugin System — Modular plugin registry with ordered loading and dependency flags.

Related MCP server: tradingprogpt

Architecture

┌──────────────────────────────────────┐
│  ai-trader-station                   │
│                                      │
│  ┌────────────────┐  ┌───────────┐  │
│  │ Signal Engine   │  │ MetaTrader│  │
│  │ BW Cascade      │──│ 5 (broker)│  │
│  ├────────────────┤  └───────────┘  │
│  │ ChaosPanel      │                │
│  │ Order Execution  │                │
│  ├────────────────┤                 │
│  │ MCP Surface     │                │
│  │ AI Tool Use     │                │
│  ├────────────────┤                 │
│  │ Chat Window     │                │
│  │ DeepSeek/Qwen   │                │
│  └────────┬───────┘                 │
└───────────┼──────────────────────────┘
            │ HTTPS (optional)
  ┌─────────▼─────────┐
  │  RunPod Serverless  │
  │  Kronos 102M       │
  │  Price Forecast    │
  └────────────────────┘

Tech Stack

Installation

Prerequisites

• Python 3.11+

• MetaTrader 5 installed and logged into a broker

• A RunPod account (for Kronos AI forecasts — optional)

• A DeepSeek API key (for AI chat — optional)

Setup

git clone https://github.com/Swigler/ai-trader-station.git
cd ai-trader-station

# Install with all dependencies
pip install -e ".[qt,mt5]"

# Copy env template and add your keys
cp .env.example .env

Environment Variables

# Required for AI chat
DEEPSEEK_API_KEY=your-deepseek-key

# Required for Kronos AI forecasts (optional)
RUNPOD_ENDPOINT=https://api.runpod.ai/v2/{endpoint-id}/run
RUNPOD_API_KEY=your-runpod-key

# Optional — Kronos local server
KRONOS_URL=http://localhost:7600

Run

python -m trade_app

Kronos AI Setup (RunPod Serverless)

Kronos is a 102.3M parameter price prediction model running on RunPod serverless GPU. Scales to zero when idle, spins up on demand.

Docker Image

radu372/kronos-serverless:v2

Step 1 — Create a Network Volume

1. Go to RunPod Console → Storage → Network Volumes

2. Create a new volume: 10 GB, pick a datacenter close to you

3. Note the volume ID

Step 2 — Download Model Weights

Spin up a temporary GPU pod with the network volume attached, then:

from huggingface_hub import snapshot_download

snapshot_download('NeoQuasar/Kronos-base',           local_dir='/workspace/kronos/model')
snapshot_download('NeoQuasar/Kronos-Tokenizer-base', local_dir='/workspace/kronos/tokenizer')

Terminate the pod after download — the weights persist on the volume.

Step 3 — Create Serverless Endpoint

1. Go to Serverless → New Endpoint

2. Container Image: radu372/kronos-serverless:v2

3. GPU: Any Ampere GPU (RTX 3060+ / A4000+ / A100)

4. Workers: Min 0, Max 1 (scale to zero)

5. Idle Timeout: 5 seconds

6. Advanced → Network Volume: attach the volume from Step 1

7. Environment Variables:

Step 4 — Test

curl -X POST "https://api.runpod.ai/v2/{endpoint-id}/runsync" \
  -H "Authorization: Bearer ${RUNPOD_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{"input": {"action": "health"}}'

Expected response:

{"output": {"status": "ok", "device": "cuda:0", "model_path": "/workspace/kronos/model"}}

Step 5 — Connect to the App

Add your endpoint URL and API key to .env or enter them in the launcher UI.

Kronos API

Single prediction:

POST /predict
{
  "bars": [{"timestamp": "...", "open": 1.1, "high": 1.2, "low": 1.0, "close": 1.15, "volume": 100, "amount": 0}],
  "pred_len": 10,
  "sample_count": 1
}

Response:

{
  "direction": "long",
  "confidence": 0.73,
  "predictions": [{"timestamp": "...", "open": ..., "high": ..., "low": ..., "close": ..., "volume": ..., "amount": ...}]
}

Kronos is a lot-sizing advisor, never a gatekeeper. Signal agrees → x1.5 lot. Disagrees → x0.5. Neutral → x1.0. The BW cascade always has final authority.

Signal Cascade

The signal engine implements Bill Williams' Trading Chaos methodology as a cascading gate system:

Fractal Trigger
  → Alligator Trend Filter (SMMA 13/8/5)
    → AO Momentum Confirmation
      → Higher Timeframe Filter
        → Zone Trading (AO + AC color)
          → Execution via ChaosPanel

Each dimension must confirm before the next activates. No signal passes without clearing every gate.

Project Structure

ai-trader-station/
├── pyproject.toml
├── .env.example
├── src/
│   └── trade_app/
│       ├── __main__.py              # Entry point
│       ├── app.py                   # Launcher + plugin loading
│       ├── constants.py
│       ├── core/
│       │   ├── signal_engine.py     # Bill Williams indicator engine
│       │   ├── executor.py          # MT5 order execution + risk sizing
│       │   └── kronos_client.py     # Kronos forecast client
│       ├── ui/
│       │   ├── trading_hub.py       # Main window + tab management
│       │   ├── ao_chart.py          # AO chart widget
│       │   ├── ao_screener.py       # Multi-symbol BW screener
│       │   ├── chat_window.py       # AI chat with MCP tool use
│       │   └── control_board.py     # ChaosPanel order execution
│       ├── integrations/
│       │   ├── mt5_utils.py         # MetaTrader 5 helpers
│       │   ├── mcp_app.py           # MCP entry point
│       │   └── mcp/
│       │       ├── bridge.py        # Thread-safe Qt bridge
│       │       ├── schema.py        # MCP tool schemas
│       │       └── interface.py     # MCP interface
│       └── plugins/
│           └── registry.py          # Plugin discovery + loading
├── tests/
│   ├── test_signal_engine.py
│   └── test_indicators.py
└── docs/                            # Screenshots

License

MIT