Languages: English | 中文 | Українська | Русский

An automated Binance futures trading system powered by DeepSeek/Qwen AI, supporting multi-AI model live trading competition, featuring comprehensive market analysis, AI decision-making, self-learning mechanism, and professional Web monitoring interface.

⚠️ Risk Warning: This system is experimental. AI auto-trading carries significant risks. Strongly recommended for learning/research purposes or testing with small amounts only!

Join our Telegram developer community to discuss, share ideas, and get support:

💬 NOFX Developer Community

• Qwen vs DeepSeek live trading battle
• Independent account management and decision logs
• Real-time performance comparison charts
• ROI PK and win rate statistics

• Historical Feedback: Analyzes last 20 cycles of trading performance before each decision
• Smart Optimization:
  • Identifies best/worst performing coins
  • Calculates win rate, profit/loss ratio, average profit
  • Avoids repeating mistakes (consecutive losing coins)
  • Reinforces successful strategies (high win rate patterns)
• Dynamic Adjustment: AI autonomously adjusts trading style based on historical performance

• 3-minute K-line: Real-time price, EMA20, MACD, RSI(7)
• 4-hour K-line: Long-term trend, EMA20/50, ATR, RSI(14)
• Open Interest Analysis: Market sentiment, capital flow judgment
• OI Top Tracking: Top 20 coins with fastest growing open interest
• AI500 Coin Pool: Automatic high-score coin screening
• Liquidity Filter: Auto-filters low liquidity coins (<15M USD position value)

• Per-Coin Position Limit:
  • Altcoins ≤ 1.5x account equity
  • BTC/ETH ≤ 10x account equity
• Fixed Leverage: Altcoins 20x | BTC/ETH 50x
• Margin Management: Total usage ≤90%, AI autonomous decision on usage rate
• Risk-Reward Ratio: Mandatory ≥1:2 (stop-loss:take-profit)
• Prevent Position Stacking: No duplicate opening of same coin/direction

• Professional Trading Interface: Binance-style visual design
• Dark Theme: Classic color scheme (Gold #F0B90B + dark background)
• Real-time Data: 5-second refresh for accounts, positions, charts
• Equity Curve: Historical account value trend (USD/percentage toggle)
• Performance Comparison Chart: Real-time multi-AI ROI comparison
• Smooth Animations: Fluid hover, transition, and loading effects

• Chain of Thought: AI's complete reasoning process (CoT)
• Historical Performance: Overall win rate, average profit, profit/loss ratio
• Recent Trades: Last 5 trade details (entry price → exit price → P/L%)
• Coin Statistics: Per-coin performance (win rate, average P/L)
• JSON Logs: Complete decision records for post-trade analysis

nofx/
├── main.go                          # Program entry (multi-trader manager)
├── config.json                      # Configuration file (API keys, multi-trader config)
│
├── api/                            # HTTP API service
│   └── server.go                   # Gin framework, RESTful API
│
├── trader/                         # Trading core
│   ├── auto_trader.go              # Auto trading main controller (single trader)
│   └── binance_futures.go          # Binance futures API wrapper
│
├── manager/                        # Multi-trader management
│   └── trader_manager.go           # Manages multiple trader instances
│
├── mcp/                            # Model Context Protocol - AI communication
│   └── client.go                   # AI API client (DeepSeek/Qwen integration)
│
├── decision/                       # AI decision engine
│   └── engine.go                   # Decision logic with historical feedback
│
├── market/                         # Market data fetching
│   └── data.go                     # Market data & technical indicators (K-line, RSI, MACD)
│
├── pool/                           # Coin pool management
│   └── coin_pool.go                # AI500 + OI Top merged pool
│
├── logger/                         # Logging system
│   └── decision_logger.go          # Decision recording + performance analysis
│
├── decision_logs/                  # Decision log storage
│   ├── qwen_trader/                # Qwen trader logs
│   └── deepseek_trader/            # DeepSeek trader logs
│
└── web/                            # React frontend
    ├── src/
    │   ├── components/             # React components
    │   │   ├── EquityChart.tsx     # Equity curve chart
    │   │   ├── ComparisonChart.tsx # Multi-AI comparison chart
    │   │   └── CompetitionPage.tsx # Competition leaderboard
    │   ├── lib/api.ts              # API call wrapper
    │   ├── types/index.ts          # TypeScript types
    │   ├── index.css               # Binance-style CSS
    │   └── App.tsx                 # Main app
    └── package.json

Backend (Go)

• github.com/adshao/go-binance/v2 - Binance API client
• github.com/markcheno/go-talib - Technical indicator calculation (TA-Lib)
• github.com/gin-gonic/gin - HTTP API framework

Frontend (React + TypeScript)

• react + react-dom - UI framework
• recharts - Chart library (equity curve, comparison charts)
• swr - Data fetching and caching
• tailwindcss - CSS framework

Before using this system, you need a Binance Futures account. Use our referral link to save on trading fees:

🎁 Register Binance - Get Fee Discount

1. Click the link above to visit Binance registration page
2. Complete registration with email/phone number
3. Complete KYC verification (required for futures trading)
4. Enable Futures account:
   • Go to Binance homepage → Derivatives → USD-M Futures
   • Click "Open Now" to activate futures trading
5. Create API Key:
   • Go to Account → API Management
   • Create new API key, enable "Futures" permission
   • Save API Key and Secret Key (needed for config.json)
   • Important: Whitelist your IP address for security

• ✅ Spot trading: Up to 30% fee discount
• ✅ Futures trading: Up to 30% fee discount
• ✅ Lifetime validity: Permanent discount on all trades

⚡ Start trading in 3 simple steps with Docker - No installation needed!

Docker automatically handles all dependencies (Go, Node.js, TA-Lib) and environment setup. Perfect for beginners!

# Copy configuration template
cp config.json.example config.json

# Edit and fill in your API keys
nano config.json  # or use any editor

# Option 1: Use convenience script (Recommended)
chmod +x start.sh
./start.sh start --build

# Option 2: Use docker-compose directly
docker-compose up -d --build

Open your browser and visit: http://localhost:3000

That's it! 🎉 Your AI trading system is now running!

./start.sh logs      # View logs
./start.sh status    # Check status
./start.sh stop      # Stop services
./start.sh restart   # Restart services

📖 For detailed Docker deployment guide, troubleshooting, and advanced configuration:

• English: See DOCKER_DEPLOY.en.md
• 中文: 查看 DOCKER_DEPLOY.md

Note: If you used Docker deployment above, skip this section. Manual installation is only needed if you want to modify the code or run without Docker.

• Go 1.21+
• Node.js 18+
• TA-Lib library (technical indicator calculation)

macOS:

brew install ta-lib

Ubuntu/Debian:

sudo apt-get install libta-lib0-dev

Other systems: Refer to TA-Lib Official Documentation

git clone https://github.com/tinkle-community/nofx.git
cd nofx

Backend:

go mod download

Frontend:

cd web
npm install
cd ..

Before configuring the system, you need to obtain AI API keys. Choose one of the following AI providers:

Why DeepSeek?

• 💰 Cheaper than GPT-4 (about 1/10 the cost)
• 🚀 Fast response time
• 🎯 Excellent trading decision quality
• 🌍 Works globally without VPN

How to get DeepSeek API Key:

1. Visit: https://platform.deepseek.com
2. Register: Sign up with email/phone number
3. Verify: Complete email/phone verification
4. Top-up: Add credits to your account
   • Minimum: ~$5 USD
   • Recommended: $20-50 USD for testing
5. Create API Key:
   • Go to API Keys section
   • Click "Create New Key"
   • Copy and save the key (starts with sk-)
   • ⚠️ Important: Save it immediately - you can't see it again!

Pricing: ~$0.14 per 1M tokens (very cheap!)

How to get Qwen API Key:

1. Visit: https://dashscope.aliyuncs.com
2. Register: Sign up with Alibaba Cloud account
3. Enable Service: Activate DashScope service
4. Create API Key:
   • Go to API Key Management
   • Create new key
   • Copy and save (starts with sk-)

Note: May require Chinese phone number for registration

Two configuration modes available:

• 🌟 Beginner Mode: Single trader + default coins (recommended!)
• ⚔️ Expert Mode: Multiple traders competition

Step 1: Copy and rename the example config file

cp config.json.example config.json

Step 2: Edit config.json with your API keys

{
  "traders": [
    {
      "id": "my_trader",
      "name": "My AI Trader",
      "ai_model": "deepseek",
      "binance_api_key": "YOUR_BINANCE_API_KEY",
      "binance_secret_key": "YOUR_BINANCE_SECRET_KEY",
      "use_qwen": false,
      "deepseek_key": "sk-xxxxxxxxxxxxx",
      "qwen_key": "",
      "initial_balance": 1000.0,
      "scan_interval_minutes": 3
    }
  ],
  "use_default_coins": true,
  "coin_pool_api_url": "",
  "oi_top_api_url": "",
  "api_server_port": 8080
}

Step 3: Replace placeholders with your actual keys

Step 4: Adjust initial balance (optional)

• initial_balance: Set to your actual Binance futures account balance
• Used to calculate profit/loss percentage
• Example: If you have 500 USDT, set "initial_balance": 500.0

✅ Configuration Checklist:

• Binance API key filled in (no quotes issues)
• Binance Secret key filled in (no quotes issues)
• DeepSeek API key filled in (starts with sk-)
• use_default_coins set to true (for beginners)
• initial_balance matches your account balance
• File saved as config.json (not .example)

For running multiple AI traders competing against each other:

{
  "traders": [
    {
      "id": "qwen_trader",
      "name": "Qwen AI Trader",
      "ai_model": "qwen",
      "binance_api_key": "YOUR_BINANCE_API_KEY_1",
      "binance_secret_key": "YOUR_BINANCE_SECRET_KEY_1",
      "use_qwen": true,
      "qwen_key": "sk-xxxxx",
      "deepseek_key": "",
      "initial_balance": 1000.0,
      "scan_interval_minutes": 3
    },
    {
      "id": "deepseek_trader",
      "name": "DeepSeek AI Trader",
      "ai_model": "deepseek",
      "binance_api_key": "YOUR_BINANCE_API_KEY_2",
      "binance_secret_key": "YOUR_BINANCE_SECRET_KEY_2",
      "use_qwen": false,
      "qwen_key": "",
      "deepseek_key": "sk-xxxxx",
      "initial_balance": 1000.0,
      "scan_interval_minutes": 3
    }
  ],
  "use_default_coins": true,
  "coin_pool_api_url": "",
  "oi_top_api_url": "",
  "api_server_port": 8080
}

Requirements for Competition Mode:

• 2 separate Binance futures accounts (different API keys)
• Both AI API keys (Qwen + DeepSeek)
• More capital for testing (recommended: 500+ USDT per account)

Default Trading Coins (when use_default_coins: true):

• BTC, ETH, SOL, BNB, XRP, DOGE, ADA, HYPE

Smart Default Behavior (v2.0.2+):

The system now automatically defaults to use_default_coins: true if:

• You don't include this field in config.json, OR
• You set it to false but don't provide coin_pool_api_url

This makes it beginner-friendly! You can even omit this field entirely.

Configuration Examples:

✅ Option 1: Explicitly set (Recommended for clarity)

"use_default_coins": true,
"coin_pool_api_url": "",
"oi_top_api_url": ""

✅ Option 2: Omit the field (uses default coins automatically)

// Just don't include "use_default_coins" at all
"coin_pool_api_url": "",
"oi_top_api_url": ""

⚙️ Advanced: Use external API

"use_default_coins": false,
"coin_pool_api_url": "http://your-api.com/coins",
"oi_top_api_url": "http://your-api.com/oi"

The system has 2 parts that run separately:

1. Backend (AI trading brain + API)
2. Frontend (Web dashboard for monitoring)

Open a terminal and run:

# Build the program (first time only, or after code changes)
go build -o nofx

# Start the backend
./nofx

What you should see:

🚀 启动自动交易系统...
✓ Trader [my_trader] 已初始化
✓ API服务器启动在端口 8080
📊 开始交易监控...

⚠️ If you see errors:

✅ Backend is running correctly when you see:

• No error messages
• "开始交易监控..." appears
• System shows account balance
• Keep this terminal window open!

Open a NEW terminal window (keep the first one running!), then:

cd web
npm run dev

What you should see:

VITE v5.x.x  ready in xxx ms

➜  Local:   http://localhost:3000/
➜  Network: use --host to expose

✅ Frontend is running when you see:

• "Local: http://localhost:3000/" message
• No error messages
• Keep this terminal window open too!

Open your web browser and visit:

🌐 http://localhost:3000

What you'll see:

• 📊 Real-time account balance
• 📈 Open positions (if any)
• 🤖 AI decision logs
• 📉 Equity curve chart

First-time tips:

• It may take 3-5 minutes for the first AI decision
• Initial decisions might say "观望" (wait) - this is normal
• AI needs to analyze market conditions first

What to watch:

✅ Healthy System Signs:

• Backend terminal shows decision cycles every 3-5 minutes
• No continuous error messages
• Account balance updates
• Web dashboard refreshes automatically

⚠️ Warning Signs:

• Repeated API errors
• No decisions for 10+ minutes
• Balance decreasing rapidly

Checking System Status:

# In a new terminal window
curl http://localhost:8080/health

Should return: {"status":"ok"}

Graceful Shutdown (Recommended):

1. Go to the backend terminal (the first one)
2. Press Ctrl+C
3. Wait for "系统已停止" message
4. Go to the frontend terminal (the second one)
5. Press Ctrl+C

⚠️ Important:

• Always stop the backend first
• Wait for confirmation before closing terminals
• Don't force quit (don't close terminal directly)

Each decision cycle (default 3 minutes), the system executes the following intelligent process:

┌──────────────────────────────────────────────────────────┐
│ 1. 📊 Analyze Historical Performance (last 20 cycles)    │
├──────────────────────────────────────────────────────────┤
│  ✓ Calculate overall win rate, avg profit, P/L ratio    │
│  ✓ Per-coin statistics (win rate, avg P/L in USDT)      │
│  ✓ Identify best/worst performing coins                 │
│  ✓ List last 5 trade details with accurate PnL          │
│  ✓ Calculate Sharpe ratio for risk-adjusted performance │
│  📌 NEW (v2.0.2): Accurate USDT PnL with leverage       │
└──────────────────────────────────────────────────────────┘
                           ↓
┌──────────────────────────────────────────────────────────┐
│ 2. 💰 Get Account Status                                 │
├──────────────────────────────────────────────────────────┤
│  • Total equity & available balance                      │
│  • Number of open positions & unrealized P/L            │
│  • Margin usage rate (AI manages up to 90%)             │
│  • Daily P/L tracking & drawdown monitoring             │
└──────────────────────────────────────────────────────────┘
                           ↓
┌──────────────────────────────────────────────────────────┐
│ 3. 🔍 Analyze Existing Positions (if any)                │
├──────────────────────────────────────────────────────────┤
│  • For each position, fetch latest market data          │
│  • Calculate real-time technical indicators:            │
│    - 3min K-line: RSI(7), MACD, EMA20                   │
│    - 4hour K-line: RSI(14), EMA20/50, ATR               │
│  • Track position holding duration (e.g., "2h 15min")   │
│    📌 NEW (v2.0.2): Shows how long each position held   │
│  • Display: Entry price, current price, P/L%, duration  │
│  • AI evaluates: Should hold or close?                  │
└──────────────────────────────────────────────────────────┘
                           ↓
┌──────────────────────────────────────────────────────────┐
│ 4. 🎯 Evaluate New Opportunities (candidate coins)       │
├──────────────────────────────────────────────────────────┤
│  • Fetch coin pool (2 modes):                           │
│    🌟 Default Mode: BTC, ETH, SOL, BNB, XRP, etc.       │
│    ⚙️  Advanced Mode: AI500 (top 20) + OI Top (top 20) │
│  • Merge & deduplicate candidate coins                  │
│  • Filter: Remove low liquidity (<15M USD OI value)     │
│  • Batch fetch market data + technical indicators       │
│  • Calculate volatility, trend strength, volume surge   │
└──────────────────────────────────────────────────────────┘
                           ↓
┌──────────────────────────────────────────────────────────┐
│ 5. 🧠 AI Comprehensive Decision (DeepSeek/Qwen)          │
├──────────────────────────────────────────────────────────┤
│  • Review historical feedback:                          │
│    - Recent win rate & profit factor                    │
│    - Best/worst coins performance                       │
│    - Avoid repeating mistakes                           │
│  • Analyze all raw sequence data:                       │
│    - 3min price序列, 4hour K-line序列                     │
│    - Complete indicator sequences (not just latest)     │
│    📌 NEW (v2.0.2): AI has full freedom to analyze     │
│  • Chain of Thought (CoT) reasoning process             │
│  • Output structured decisions:                         │
│    - Action: close_long/close_short/open_long/open_short│
│    - Coin symbol, quantity, leverage                    │
│    - Stop-loss & take-profit levels (≥1:2 ratio)        │
│  • Decision: Wait/Hold/Close/Open                       │
└──────────────────────────────────────────────────────────┘
                           ↓
┌──────────────────────────────────────────────────────────┐
│ 6. ⚡ Execute Trades                                      │
├──────────────────────────────────────────────────────────┤
│  • Priority order: Close existing → Then open new       │
│  • Risk checks before execution:                        │
│    - Position size limits (1.5x for altcoins, 10x BTC) │
│    - No duplicate positions (same coin + direction)     │
│    - Margin usage within 90% limit                      │
│  • Auto-fetch & apply Binance LOT_SIZE precision        │
│  • Execute orders via Binance Futures API               │
│  • After closing: Auto-cancel all pending orders        │
│  • Record actual execution price & order ID             │
│  📌 Track position open time for duration calculation   │
└──────────────────────────────────────────────────────────┘
                           ↓
┌──────────────────────────────────────────────────────────┐
│ 7. 📝 Record Complete Logs & Update Performance          │
├──────────────────────────────────────────────────────────┤
│  • Save decision log to decision_logs/{trader_id}/      │
│  • Log includes:                                        │
│    - Complete Chain of Thought (CoT)                    │
│    - Input prompt with all market data                  │
│    - Structured decision JSON                           │
│    - Account snapshot (balance, positions, margin)      │
│    - Execution results (success/failure, prices)        │
│  • Update performance database:                         │
│    - Match open/close pairs by symbol_side key          │
│      📌 NEW: Prevents long/short conflicts             │
│    - Calculate accurate USDT PnL:                       │
│      PnL = Position Value × Price Δ% × Leverage         │
│      📌 NEW: Considers quantity + leverage              │
│    - Store: quantity, leverage, open time, close time   │
│    - Update win rate, profit factor, Sharpe ratio       │
│  • Performance data feeds back into next cycle          │
└──────────────────────────────────────────────────────────┘
                           ↓
                    (Repeat every 3-5 min)

📌 Position Duration Tracking:

• System now tracks how long each position has been held
• Displayed in user prompt: "持仓时长2小时15分钟"
• Helps AI make better decisions on when to exit

📌 Accurate PnL Calculation:

• Previously: Only percentage (100U@5% = 1000U@5% = both showed "5.0")
• Now: Real USDT profit = Position Value × Price Change × Leverage
• Example: 1000 USDT × 5% × 20x = 1000 USDT actual profit

📌 Enhanced AI Freedom:

• AI can freely analyze all raw sequence data
• No longer restricted to predefined indicator combinations
• Can perform own trend analysis, support/resistance calculation

📌 Improved Position Tracking:

• Uses symbol_side key (e.g., "BTCUSDT_long")
• Prevents conflicts when holding both long & short
• Stores complete data: quantity, leverage, open/close times

## 📊 Historical Performance Feedback

### Overall Performance
- **Total Trades**: 15 (Profit: 8 | Loss: 7)
- **Win Rate**: 53.3%
- **Average Profit**: +3.2% | Average Loss: -2.1%
- **Profit/Loss Ratio**: 1.52:1

### Recent Trades
1. BTCUSDT LONG: 95000.0000 → 97500.0000 = +2.63% ✓
2. ETHUSDT SHORT: 3500.0000 → 3450.0000 = +1.43% ✓
3. SOLUSDT LONG: 185.0000 → 180.0000 = -2.70% ✗
4. BNBUSDT LONG: 610.0000 → 625.0000 = +2.46% ✓
5. ADAUSDT LONG: 0.8500 → 0.8300 = -2.35% ✗

### Coin Performance
- **Best**: BTCUSDT (Win rate 75%, avg +2.5%)
- **Worst**: SOLUSDT (Win rate 25%, avg -1.8%)

1. Avoid consecutive losers: Seeing SOLUSDT with 3 consecutive stop-losses, AI avoids or is more cautious
2. Reinforce successful strategies: BTC breakout long with 75% win rate, AI continues this pattern
3. Dynamic style adjustment: Win rate <40% → conservative; P/L ratio >2 → maintain aggressive
4. Identify market conditions: Consecutive losses may indicate choppy market, reduce trading frequency

• 🏆 Leaderboard: Real-time ROI ranking, golden border highlights leader
• 📈 Performance Comparison: Dual AI ROI curve comparison (purple vs blue)
• ⚔️ Head-to-Head: Direct comparison showing lead margin
• Real-time Data: Total equity, P/L%, position count, margin usage

• Equity Curve: Historical trend chart (USD/percentage toggle)
• Statistics: Total cycles, success/fail, open/close stats
• Position Table: All position details (entry price, current price, P/L%, liquidation price)
• AI Decision Logs: Recent decision records (expandable CoT)

• System status, account info, position list: 5-second refresh
• Decision logs, statistics: 10-second refresh
• Equity charts: 10-second refresh

GET /api/competition          # Competition leaderboard (all traders)
GET /api/traders              # Trader list

GET /api/status?trader_id=xxx            # System status
GET /api/account?trader_id=xxx           # Account info
GET /api/positions?trader_id=xxx         # Position list
GET /api/equity-history?trader_id=xxx    # Equity history (chart data)
GET /api/decisions/latest?trader_id=xxx  # Latest 5 decisions
GET /api/statistics?trader_id=xxx        # Statistics

GET /health                   # Health check
GET /api/config               # System configuration

1. Cryptocurrency markets are extremely volatile, AI decisions don't guarantee profit
2. Futures trading uses leverage, losses may exceed principal
3. Extreme market conditions may lead to liquidation risk
4. Funding rates may affect holding costs
5. Liquidity risk: Some coins may experience slippage

1. Network latency may cause price slippage
2. API rate limits may affect trade execution
3. AI API timeouts may cause decision failures
4. System bugs may trigger unexpected behavior

✅ Recommended

• Use only funds you can afford to lose for testing
• Start with small amounts (recommended 100-500 USDT)
• Regularly check system operation status
• Monitor account balance changes
• Analyze AI decision logs to understand strategy

❌ Not Recommended

• Invest all funds or borrowed money
• Run unsupervised for long periods
• Blindly trust AI decisions
• Use without understanding the system
• Run during extreme market volatility

Solution: Install TA-Lib library

# macOS
brew install ta-lib

# Ubuntu
sudo apt-get install libta-lib0-dev

Solution: System auto-handles precision from Binance LOT_SIZE. If error persists, check network connection.

Solution:

• Check if API key is correct
• Check network connection (may need proxy)
• System timeout is set to 120 seconds

Solution:

• Ensure backend is running (http://localhost:8080)
• Check if port 8080 is occupied
• Check browser console for errors

Solution:

• Coin pool API is optional
• If API fails, system uses default mainstream coins (BTC, ETH, etc.)
• Check API URL and auth parameter in config.json

1. Set reasonable decision cycle: Recommended 3-5 minutes, avoid over-trading
2. Control candidate coin count: System defaults to AI500 top 20 + OI Top top 20
3. Regularly clean logs: Avoid excessive disk usage
4. Monitor API call count: Avoid triggering Binance rate limits
5. Test with small capital: First test with 100-500 USDT for strategy validation

Critical Bug Fixes - Trade History & Performance Analysis:

This version fixes critical calculation errors in the historical trade record and performance analysis system that significantly affected profitability statistics.

1. PnL Calculation - Major Error Fixed (logger/decision_logger.go)

• Problem: Previously calculated PnL as percentage only, completely ignoring position size and leverage
  • Example: 100 USDT position earning 5% and 1000 USDT position earning 5% both showed 5.0 as profit
  • This made performance analysis completely inaccurate
• Solution: Now calculates actual USDT profit amount

  PnL (USDT) = Position Value × Price Change % × Leverage
  Example: 1000 USDT × 5% × 20x = 1000 USDT actual profit
  

• Impact: Win rate, profit factor, and Sharpe ratio now based on accurate USDT amounts

2. Position Tracking - Missing Critical Data

• Problem: Open position records only stored price and time, missing quantity and leverage
• Solution: Now stores complete trade data:
  • quantity: Position size (in coins)
  • leverage: Leverage multiplier (e.g., 20x)
  • These are essential for accurate PnL calculations

3. Position Key Logic - Long/Short Conflict

• Problem: Used symbol as position key, causing data conflicts when holding both long and short
  • Example: BTCUSDT long and BTCUSDT short would overwrite each other
• Solution: Changed to symbol_side format (e.g., BTCUSDT_long, BTCUSDT_short)
  • Now properly distinguishes between long and short positions

4. Sharpe Ratio Calculation - Code Optimization

• Problem: Used custom Newton's method for square root calculation
• Solution: Replaced with standard library math.Sqrt
  • More reliable, maintainable, and efficient

Why This Update Matters:

• ✅ Historical trade statistics now show real USDT profit/loss instead of meaningless percentages
• ✅ Performance comparison between different leverage trades is now accurate
• ✅ AI self-learning mechanism receives correct historical feedback
• ✅ Profit factor and Sharpe ratio calculations are now meaningful
• ✅ Multi-position tracking (long + short simultaneously) works correctly

Recommendation: If you were running the system before this update, your historical statistics were inaccurate. After updating to v2.0.2, new trades will be calculated correctly.

Bug Fixes:

• ✅ Fixed ComparisonChart data processing logic - switched from cycle_number to timestamp grouping
• ✅ Resolved chart freezing issue when backend restarts and cycle_number resets
• ✅ Improved chart data display - now shows all historical data points chronologically
• ✅ Enhanced debugging logs for better troubleshooting

Major Updates:

• ✅ AI self-learning mechanism (historical feedback, performance analysis)
• ✅ Multi-trader competition mode (Qwen vs DeepSeek)
• ✅ Binance-style UI (complete Binance interface imitation)
• ✅ Performance comparison charts (real-time ROI comparison)
• ✅ Risk control optimization (per-coin position limit adjustment)

Bug Fixes:

• Fixed hardcoded initial balance issue
• Fixed multi-trader data sync issue
• Optimized chart data alignment (using cycle_number)

• Initial release
• Basic AI trading functionality
• Decision logging system
• Simple Web interface

MIT License - See LICENSE file for details

Issues and Pull Requests are welcome!

1. Fork the project
2. Create feature branch (git checkout -b feature/AmazingFeature)
3. Commit changes (git commit -m 'Add some AmazingFeature')
4. Push to branch (git push origin feature/AmazingFeature)
5. Open Pull Request

• Twitter/X: @Web3Tinkle
• GitHub Issues: Submit an Issue

• Binance API - Binance Futures API
• DeepSeek - DeepSeek AI API
• Qwen - Alibaba Cloud Qwen
• TA-Lib - Technical indicator library
• Recharts - React chart library

Last Updated: 2025-10-29 (v2.0.2)

⚡ Explore the possibilities of quantitative trading with the power of AI!