TradeMind

Krypto-Tradingbot (Python) mit Paper-/Simulationsmodus, Live-Trading und Antrainierung der Strategie.

Per Podman deploybar. Alle API-Keys werden aus der config.yaml oder aus Environment-Variablen gelesen.

Features

Paper / Simulation: führt Käufe & Verkäufe gegen einen Candles-Feed durch, ohne echtes Geld.
Live: platziert reale Markerorders über ccxt (Binance, Kraken, Coinbase, KuCoin, OKX, Bybit, BitMEX …).
Antrainieren (train): evolutionäre Optimierung der Strategie-Parameter + Signalgewichte auf Simulationsdaten (Fitness = gewichteter Return + Sharpe − Max-Drawdown).
Kernstrategie: MACD-Cross + RSI + ATR-Stop-Loss.
REST-API + Dashboard (serve): Web-Dashboard + API für Status, Signals, Equity, Paper-Launch – Port frei anpassbar.
Konfiguration: eine config.yaml, mehrere Exchanges in state/weights.json persistierbar.

Installation (lokal / Dev)

python -m venv .venv
.venv\Scripts\activate        # Windows
pip install -r requirements.txt
python -m trademind --help

Podman (empfohlener Deploy)

# 1. Build
podman build -t trademind:latest -f Podmanfile .

# 2. Paper-Modus (kein API-Key nötig)
podman run --rm trademind:latest paper --config /app/config.yaml

# 3. Training (Strategie wird antrainiert)
podman run --rm -v $PWD/state:/app/state trademind:latest train --config /app/config.yaml

# 4. Live-Trading (NUR mit echten Keys + sandbox: false)
podman run -it --rm \
  -e BINANCE_API_KEY=... \
  -e BINANCE_API_SECRET=... \
  trademind:latest live --config /app/config.yaml

Mit `podman-compose` (optional)

pip install podman-compose        # ein Mal
podman-compose build
podman-compose up paper           # Simulationslauf
podman-compose run --rm train     # Antrainieren
podman-compose run --rm live      # Live-Zyklus
TM_PORT=9000 podman-compose up serve   # API/Dashboard auf Host-Port 9000

Konfiguration (`config.yaml`)

trading:
  base_currency: BTC
  quote_currency: USDT
  initial_balance: 10000
  position_size_pct: 0.10
  fee_pct: 0.001
  slippage_pct: 0.0005
  timeframe: 1h
  candles: 500

strategy:
  fast_period: 12
  slow_period: 26
  rsi_overbought: 70
  rsi_oversold: 30
  atr_stop_mult: 2.5
  allow_long: true
  allow_short: false

training:
  generations: 15
  population: 30
  seed: 42
  state_file: state/weights.json

server:
  host: 0.0.0.0
  port: 8080              # REST-API/Dashboard (trademind serve)

exchanges:
  binance:
    api_key: ${BINANCE_API_KEY}
    api_secret: ${BINANCE_API_SECRET}
    sandbox: true
  kraken:
    api_key: ${KRAKEN_API_KEY}
    api_secret: ${KRAKEN_API_SECRET}
    sandbox: true
  coinbase:
    api_key: ${COINBASE_API_KEY}
    api_secret: ${COINBASE_API_SECRET}
    sandbox: true
  kucoin:
    api_key: ${KUCOIN_API_KEY}
    api_secret: ${KUCOIN_API_SECRET}
    password: ${KUCOIN_PASSPHRASE}
    sandbox: true

CLI

trademind paper   # Paper-/Simulationslauf (Echte Marktkurse, Orders nur simuliert)
trademind live    # ein Live-Zyklus (echte Orders)
trademind train   # optimiert die Strategie-Parameter & -gewichte
trademind serve   # STARTET REST-API + HTML-DASHBOARD (Port: server.port / --port)
trademind show    # zeigt die geladene Konfiguration (Keys maskiert)

REST-API + Dashboard (`serve`)

# lokal (Port frei wählbar – CLI > Env > config.yaml)
trademind serve --port 9000 --data mock
TM_PORT=9000 tm serve              # Env-Override

# Podman (Host-Port über TM_PORT anpassbar)
podman run --rm -p 9000:8080 trademind:latest serve --config /app/config.yaml

Endpunkt	Beschreibung
`GET /`	HTML-Dashboard (Status-Kacheln, Equity-Chart, Signal-Tabelle)
`GET /api/health`	Liveness
`GET /api/status`	Konfiguration, aktives Symbol, letztes Paper-Ergebnis
`GET /api/signals?limit=25`	zuletzt berechnete Signals (Score, Preis, Grund)
`GET /api/equity`	Equity-Kurve des letzten Paper-Laufs
`POST /api/paper`	startet einen Paper-Lauf (simuliert, keine Live-Orders)

Der Server ist rein read-only bzw. simuliert – er platziert nie Live-Orders.

Kursdatenquellen (paper & train)

Die Standard-Modus --data auto nutzt echte Marktkurse über die öffentliche ccxt-API (Binance ist default) – keine API-Keys nötig. Bei Erreichbarkeitsproblemen fällt automatisch auf generierte mock-Daten zurück.

trademind paper --data live --exchange kraken     # zwingend live (sonst Fehler)
trademind paper --data mock                       # deterministische Offline-Daten
trademind train --data live --exchange coinbase   # Training auf echten Kursdaten

Antrainieren im Detail

trademind train erzeugt eine Population randomisierter Parameter (fast/slow/signal, rsi_*, atr_stop_mult, Signalgewichte) und optimiert sie per Elitismus + Crossover + Mutation so, dass die gewichtete Fitness gestiegen ist:

Fitness  =  0.6 × TotalReturn  +  0.3 × (Sharpe/10)  −  0.1 × MaxDrawdown

Das Ergebnis wird in state/weights.json gespeichert und bei paper / live automatisch geladen.

Sicherheit / Haftung

Paper-/Simulationsmodus nutzt keine echten Order.
Live-Orders sind auf eigenes Risiko. Es gibt keine Garantie für Erträge.
API-Keys niemals committen.

Tests

pip install pytest httpx
python -m pytest

5.3 KiB Raw Permalink Blame History Unescape Escape