LLM-TradeBot
A multi-agent AI trading system using LLMs to optimize strategies and adapt to market conditions in real-time.
Stars: 174
LLM-TradeBot is an Intelligent Multi-Agent Quantitative Trading Bot based on the Adversarial Decision Framework (ADF). It achieves high win rates and low drawdown in automated futures trading through market regime detection, price position awareness, dynamic score calibration, and multi-layer physical auditing. The bot prioritizes judging 'IF we should trade' before deciding 'HOW to trade' and offers features like multi-agent collaboration, agent configuration, agent chatroom, AUTO1 symbol selection, multi-LLM support, multi-account trading, async concurrency, CLI headless mode, test/live mode toggle, safety mechanisms, and full-link auditing. The system architecture includes a multi-agent architecture with various agents responsible for different tasks, a four-layer strategy filter, and detailed data flow diagrams. The bot also supports backtesting, full-link data auditing, and safety warnings for users.
README:
Intelligent Multi-Agent Quantitative Trading Bot based on the Adversarial Decision Framework (ADF). Achieves high win rates and low drawdown in automated futures trading through market regime detection, price position awareness, dynamic score calibration, and multi-layer physical auditing.
Experience the bot immediately through our web interface: ๐ Live Dashboard
- LLM toggle stays off by default; turning it on prompts for an API key.
- Agent Chatroom shows per-cycle agent outputs and the final Decision Core action.
- Real-time Balance Curve uses a fixed initial balance and PnL-driven current balance.
- Agent Config lets you edit per-agent parameters and (if applicable) system prompts.
- ๐ต๏ธ Perception First: Unlike strict indicator-based systems, this framework prioritizes judging "IF we should trade" before deciding "HOW to trade".
- ๐ค Multi-Agent Collaboration: Core + optional agents with LLM and Local variants for flexible deployment.
- ๐๏ธ Agent Configuration: Enable/disable optional agents via Dashboard, environment variables, or config file for customized strategy.
- ๐ฌ Agent Chatroom: Chat-style multi-agent outputs per cycle, with Decision Core final decisioning.
- ๐งฉ Agent Config Tabs: Configure per-agent parameters and optional system prompts directly in the Dashboard.
- ๐ฐ AUTO1 Symbol Selection: Intelligent single-symbol selection based on momentum, volume, and technical indicators.
- ๐ง Multi-LLM Support: Seamlessly switch between DeepSeek, OpenAI, Claude, Qwen, and Gemini via Dashboard settings.
- ๐ Multi-Account Trading: Manage multiple exchange accounts with unified API abstraction (currently Binance, extensible).
- โก Async Concurrency: Currently fetches multi-timeframe data (5m/15m/1h) concurrently, ensuring data alignment at the snapshot moment.
- ๐ฅ๏ธ CLI Headless Mode: Run without Web UI for headless servers - rich terminal output with 93% less log verbosity.
- ๐งช๐ฐ Test/Live Mode Toggle: Quick switch between paper trading and live trading with visual confirmation.
- ๐ก๏ธ Safety First: Stop-loss direction correction, capital pre-rehearsal, and veto mechanisms to safeguard live trading.
- ๐ Full-Link Auditing: Every decision's adversarial process and confidence penalty details are recorded, achieving true "White-Box" decision-making.
flowchart TD
A["๐ฏ Symbol Selector"] --> B["๐ต๏ธ DataSync (5m/15m/1h)"]
B --> C["๐จโ๐ฌ Quant Analyst"]
C --> D["๐งญ Multi-Period Parser"]
C --> E["๐ฎ Trend / ๐ Setup / โก Trigger (LLM or Local)"]
C --> F["๐ช Reflection (optional)"]
D --> G["โ๏ธ Decision Core"]
E --> G
F --> G
G --> H["๐ก๏ธ Risk Audit"]
H --> I["๐ Execution Engine"]Design highlights
- Symbol Selection chooses the active symbol(s) before analysis.
- DataSync aligns multi-timeframe data at the same snapshot moment.
- Quant Analyst produces numeric signals (trend/osc/sentiment/traps).
- Semantic Agents (Trend/Setup/Trigger) provide human-readable reasoning (LLM or local).
- Multi-Period Parser compresses 1h/15m/5m alignment into a Decision Core input.
- Decision Core fuses all enabled agent outputs into final action/confidence.
- Risk Audit can veto or adjust before execution.
- Reflection summarizes performance and feeds back into decisions.
๐ Detailed Docs: See Data Flow Analysis for complete mechanisms.
| Exchange | Status | Register (Fee Discount) |
|---|---|---|
| Binance | โ Supported | Register |
| Bybit | ๐๏ธ Coming Soon | Register |
| OKX | ๐๏ธ Coming Soon | Register |
| Bitget | ๐๏ธ Coming Soon | Register |
| Exchange | Status | Register (Fee Discount) |
|---|---|---|
| Hyperliquid | ๐๏ธ Coming Soon | Register |
| Aster DEX | ๐๏ธ Coming Soon | Register |
| Lighter | ๐๏ธ Coming Soon | Register |
| AI Model | Status | Get API Key |
|---|---|---|
| DeepSeek | โ Supported | Get API Key |
| Qwen | โ Supported | Get API Key |
| OpenAI (GPT) | โ Supported | Get API Key |
| Claude | โ Supported | Get API Key |
| Gemini | โ Supported | Get API Key |
| Grok | ๐๏ธ Coming Soon | Get API Key |
| Kimi | ๐๏ธ Coming Soon | Get API Key |
For Complete Beginners:
- This is an automated trading bot that trades cryptocurrency futures on Binance
- It uses AI (LLM) and machine learning to make trading decisions
- Test mode lets you practice with virtual money before risking real funds
- The bot runs 24/7 and makes decisions based on market analysis
Technical Level: Intermediate Python knowledge recommended but not required for basic usage.
No need to manually configure Python environment! Use our automated installation scripts:
# 1. Clone the project
git clone <your-repo-url>
cd LLM-TradeBot
# 2. One-click install
chmod +x install.sh
./install.sh
# 3. Configure API keys
vim .env # Edit and add your API keys
# 4. One-click start
./start.shVisit Dashboard: http://localhost:8000
# 1. Clone the project
git clone <your-repo-url>
cd LLM-TradeBot
# 2. Configure environment
cp .env.example .env
vim .env # Edit and add your API keys
# 3. One-click start
cd docker && docker-compose up -d๐ Detailed Guide: See QUICKSTART.md
Before you start, make sure you have:
- โ Git installed (Download here)
- โ Python 3.11+ OR Docker (installation script will check)
- โ Nothing else needed! Test mode uses virtual balance
- โ Binance Account (Sign up here)
- โ Binance Futures API Keys with trading permissions
- โ USDT in Futures Wallet (minimum $100 recommended)
โ ๏ธ Risk Warning: Only trade with money you can afford to lose
The bot supports 8 LLM providers. Configure via environment variables or Dashboard Settings:
| Provider | Model | Cost | Speed | Get API Key |
|---|---|---|---|---|
| DeepSeek (Recommended) | deepseek-chat | ๐ฐ Low | โก Fast | platform.deepseek.com |
| OpenAI | gpt-4o, gpt-4o-mini | ๐ฐ๐ฐ๐ฐ High | โก Fast | platform.openai.com |
| Claude | claude-3-5-sonnet | ๐ฐ๐ฐ Medium | โก Fast | console.anthropic.com |
| Qwen | qwen-turbo, qwen-plus | ๐ฐ Low | โก Fast | dashscope.console.aliyun.com |
| Gemini | gemini-1.5-pro | ๐ฐ Low | โก Fast | aistudio.google.com |
| Kimi | moonshot-v1-8k | ๐ฐ Low | โก Fast | platform.moonshot.ai |
| MiniMax | MiniMax-M2.1 | ๐ฐ Low | โก Fast | platform.minimax.io |
| GLM | glm-4-flash | ๐ฐ Low | โก Fast | open.bigmodel.cn |
Method 1: Environment Variables (Recommended)
Edit your .env file:
# Select LLM Provider (required)
LLM_PROVIDER=deepseek # Options: deepseek, openai, claude, qwen, gemini, kimi, minimax, glm
# Configure API Key for your selected provider
DEEPSEEK_API_KEY=sk-xxx # if using DeepSeek
OPENAI_API_KEY=sk-xxx # if using OpenAI
CLAUDE_API_KEY=sk-xxx # if using Claude
QWEN_API_KEY=sk-xxx # if using Qwen
GEMINI_API_KEY=xxx # if using Gemini
KIMI_API_KEY=sk-xxx # if using Kimi
MINIMAX_API_KEY=sk-xxx # if using MiniMax
GLM_API_KEY=sk-xxx # if using GLMMethod 2: Dashboard Settings
- Open Dashboard at
http://localhost:8000 - Click โ๏ธ Settings โ API Keys tab
- Select your preferred LLM provider and enter API key
- Click Save - changes apply on next trading cycle
Method 3: Config File (config.yaml)
llm:
provider: "deepseek" # or: openai, claude, qwen, gemini, kimi, minimax, glm
model: "deepseek-chat" # provider-specific model
temperature: 0.3
max_tokens: 2000
api_keys:
deepseek: "sk-xxx"
openai: "sk-xxx"
# ... other providersIf you prefer manual setup:
pip install -r requirements.txt# Copy environment variable template
cp .env.example .env
# Set API Keys
./set_api_keys.sh# Copy config template
cp config.example.yaml config.yamlEdit config.yaml to set parameters:
- Trading pair (symbol)
- Max position size (max_position_size)
- Leverage (leverage)
- Stop loss/Take profit % (stop_loss_pct, take_profit_pct)
You can also configure all settings from the Dashboard:
Settings Modal with 4 tabs: API Keys (LLM Provider), Accounts (Multi-Account), Trading, Strategy (Prompt)
Built-in modern real-time monitoring dashboard.
Simulates trading with virtual balance ($1000). No real trades executed.
# Start with test mode
python main.py --test --mode continuousRun the bot without Web Dashboard, perfect for headless servers or terminal-only environments.
# Basic CLI mode (manual start required)
python main.py --test --headless
# Custom interval (1 minute cycles)
python main.py --test --headless --interval 1Features:
- โ No Web UI - runs entirely in terminal
- โ Rich formatted output with colors and tables
- โ Real-time price updates and trading decisions
- โ Account summary panel after each cycle
- โ Graceful shutdown with session statistics (Ctrl+C)
- โ Optimized log output (93% less verbose than Web mode)
Output Example:
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ ๐ค LLM-TradeBot CLI - TEST MODE โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโ Cycle #1 | LINKUSDT, NEARUSDT โโโโโโโโโโโโ
๐ Analyzing LINKUSDT...
โ
Data ready: $13.29
โธ๏ธ HOLD | Confidence: 45.0%
Reason: No clear 1h trend
โญโโโโโโโโโโโโโโโ Account Summary โโโโโโโโโโโโโโโโโโโโฎ
โ ๐ฐ Equity: $1,000.00 โ
โ ๐ Available: $900.00 โ
โ ๐ PnL: $0.00 (0.00%) โ
โฐโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฏ
โณ Next cycle in 1.0 minutes...
For production live trading, use the simplified CLI script that skips non-essential components:
# Activate virtual environment first
source venv/bin/activate
# Test mode - single run
python simple_cli.py --mode once
# Test mode - continuous (3-minute intervals)
python simple_cli.py --mode continuous --interval 3
# LIVE mode - continuous trading (โ ๏ธ REAL MONEY)
python simple_cli.py --mode continuous --interval 3 --live
# Custom symbols (overrides .env)
python simple_cli.py --mode continuous --symbols BTCUSDT,ETHUSDT --live
# AUTO3 mode - automatic symbol selection
python simple_cli.py --mode continuous --symbols AUTO3 --liveFeatures:
- โ Minimal footprint - only core trading components loaded
- โ Production-ready - designed for stable 24/7 operation
- โ AUTO3 support - automatic best symbol selection via backtest
- โ LLM integration - full multi-agent decision system
- โ Risk management - built-in risk audit and position limits
- โ Graceful shutdown - Ctrl+C for clean exit
Configuration:
The script reads trading symbols from .env file by default:
# In your .env file
TRADING_SYMBOLS=BTCUSDT,ETHUSDT
# Or use AUTO3 for automatic selection
TRADING_SYMBOLS=AUTO3- Valid Binance Futures API keys in
.env - Sufficient USDT balance in Futures wallet
- API permissions: Read + Futures Trading enabled
- DeepSeek/OpenAI API key for LLM decisions
# Start live trading
python main.py --mode continuousPrerequisites for Live Trading:
- Valid Binance Futures API keys configured in
.env- Sufficient USDT balance in Futures wallet
- API permissions: Read + Futures Trading enabled
After startup, visit: http://localhost:8000 (or use our Cloud Hosting)
Dashboard Features:
-
๐งช๐ฐ Test/Live Mode Toggle: Quick switch between paper trading and real trading with visual confirmation
-
๐ Real-time Balance Curve: Fixed initial balance with PnL-driven current balance
-
๐ฌ Agent Chatroom: Per-cycle multi-agent outputs with Decision Core final action
-
๐งญ Multi-Period Summary: Alignment snapshot from 1h/15m/5m signals
-
๐งฉ Agent Config Tabs: Per-agent parameters + optional system prompts
-
๐ Trade History: Complete record of all trades with Open/Close cycles and PnL statistics
-
๐ Live Log Output: Real-time scrolling logs with agent documentation sidebar, simplified/detailed mode toggle
All indicators use semantic icons and two-line display format for quick visual scanning:
๐ System Columns
- Time: Decision timestamp
- Cycle: Trading cycle number
- Symbol: Trading pair (e.g., BTCUSDT)
โ๏ธ Critic (Decision Core)
- Result: Final action (LONG/SHORT/WAIT)
- Conf: Decision confidence (0-100%)
- Reason: Decision rationale (hover for full text)
๐จโ๐ฌ Strategist (Quant Analysis)
-
1h/15m/5m: Multi-timeframe signals
- Format:
T:UP(Trend) /O:DN(Oscillator) - Colors: Green (UP), Red (DN), Gray (NEU)
- Format:
- Sent: Sentiment score with icon (๐/๐/โ)
๐ฎ Prophet (ML Prediction)
- Format:
๐ฎโ+65% - Direction: โUP (>55%), โNEU (45-55%), โDN (<45%)
๐๐ป Bull/Bear (Adversarial Analysis)
-
Bull:
โBull/๐ฅBull+ confidence % -
Bear:
โBear/๐ฅBear+ confidence % - Stance: ๐ฅStrong, โSlight, โNeutral, โUnclear
๐ Context (Market State)
-
Regime:
๐UP/๐DN/ใฐ๏ธCHOP -
Position:
๐HIGH/โMID/๐ปLOW+ percentage
๐ก๏ธ Guardian (Risk Control)
-
Risk:
โ SAFE/โ ๏ธWARN/๐จDANGER -
Guard:
โ PASS/โBLOCK(with reason on hover) - Aligned: โ Multi-period aligned / โ Not aligned
# Stop the bot
pkill -f "python main.py"
# Restart the bot (Test Mode)
pkill -f "python main.py"; sleep 2; python main.py --test --mode continuous
# View running processes
ps aux | grep "python main.py"
# View logs in terminal (if running in background)
tail -f logs/trading_$(date +%Y%m%d).logLLM-TradeBot/
โโโ src/ # Core Source Code
โ โโโ agents/ # Multi-Agent Definitions (DataSync, Quant, Decision, Risk)
โ โโโ api/ # Binance API Client
โ โโโ data/ # Data Processing (processor, validator)
โ โโโ exchanges/ # ๐ Multi-Account Exchange Abstraction
โ โ โโโ base.py # BaseTrader ABC + Data Models
โ โ โโโ binance_trader.py # Binance Futures Implementation
โ โ โโโ factory.py # Exchange Factory
โ โ โโโ account_manager.py # Multi-Account Manager
โ โโโ execution/ # Order Execution Engine
โ โโโ features/ # Feature Engineering
โ โโโ llm/ # ๐ Multi-LLM Interface
โ โ โโโ base.py # BaseLLMClient ABC
โ โ โโโ openai_client.py # OpenAI Implementation
โ โ โโโ deepseek_client.py # DeepSeek Implementation
โ โ โโโ claude_client.py # Anthropic Claude
โ โ โโโ qwen_client.py # Alibaba Qwen
โ โ โโโ gemini_client.py # Google Gemini
โ โ โโโ factory.py # LLM Factory
โ โโโ monitoring/ # Monitoring & Logging
โ โโโ risk/ # Risk Management
โ โโโ strategy/ # LLM Decision Engine
โ โโโ utils/ # Utilities (DataSaver, TradeLogger, etc.)
โ
โโโ docs/ # Documentation
โ โโโ data_flow_analysis.md # Data Flow Analysis
โ โโโ ScreenShot_2026-01-21_003126_160.png # Dashboard
โ โโโ Backtesting.png # Backtesting UI
โ
โโโ data/ # Structured Data Storage (Archived by Date)
โ โโโ market_data/ # Raw K-Line Data
โ โโโ indicators/ # Technical Indicators
โ โโโ features/ # Feature Snapshots
โ โโโ decisions/ # Final Decision Results
โ โโโ execution/ # Execution Records
โ
โโโ config/ # Configuration Files
โ โโโ accounts.example.json # ๐ Multi-Account Config Template
โ
โโโ logs/ # System Runtime Logs
โโโ tests/ # Unit Tests
โ
โโโ main.py # Main Entry Point (Multi-Agent Loop)
โโโ config.yaml # Trading Parameters
โโโ .env # API Key Configuration
โโโ requirements.txt # Python Dependencies
The system uses a Four-Layer Strategy Filter with a multi-agent pipeline. Core agents are always enabled, while optional agents can be configured via Dashboard or config.yaml.
Key Feature: Agents have LLM and Local variants - LLM versions use AI for semantic analysis, while Local versions use fast rule-based heuristics.
| Agent | Role | Responsibility |
|---|---|---|
| ๐ต๏ธ DataSyncAgent | The Oracle | Async concurrent fetch of 5m/15m/1h K-lines, ensuring snapshot consistency |
| ๐จโ๐ฌ QuantAnalystAgent | The Strategist | Generates trend scores, oscillators, sentiment, and OI Fuel (Volume Proxy) |
| ๐ก๏ธ RiskAuditAgent | The Guardian | Risk audit with absolute veto power on all trades |
| ๐งญ MultiPeriodParserAgent | The Summarizer | Multi-period alignment summary for Decision Core |
| Agent | Role | Responsibility |
|---|---|---|
| ๐ฐ SymbolSelectorAgent | AUTO1/3 Selector | Two-stage backtest selection: AI500 Top10 + Majors โ Top 5 (1h) โ Top 2 (15m) |
| Agent | Role | Responsibility |
|---|---|---|
| ๐ฏ PredictAgent | The Prophet | Predicts price probability using LightGBM ML model (auto-retrain every 2h) |
| ๐ค AIPredictionFilterAgent | AI Validator | AI-Trend alignment verification with veto power |
| ๐ฎ RegimeDetectorAgent | Regime Analyzer | Detects market state (Trending/Choppy/Ranging) and ADX strength |
| ๐ PositionAnalyzerAgent | Position Tracker | Price position analysis (High/Mid/Low zone) and S/R level detection |
| โก TriggerDetectorAgent | Entry Scanner | 5m pattern detection and trigger signal scoring |
| Agent | LLM Version | Local Version | Responsibility |
|---|---|---|---|
| ๐ TrendAgent | TrendAgentLLM |
TrendAgent |
1h trend semantic analysis (UPTREND/DOWNTREND) |
| ๐ SetupAgent | SetupAgentLLM |
SetupAgent |
15m setup zone analysis (KDJ, Bollinger Bands, entry zones) |
| ๐ฅ TriggerAgent | TriggerAgentLLM |
TriggerAgent |
5m trigger signal analysis (CONFIRMED/WAITING) |
| Agent | Role | Responsibility |
|---|---|---|
| โ๏ธ DecisionCoreAgent | The Critic | Aggregates multi-agent outputs into a final action |
| ๐ ExecutionEngine | The Executor | Precision order execution and state management |
| ๐ช ReflectionAgent | The Philosopher | Trade reflection every 10 trades (LLM or Local variant) |
Agents can be configured in multiple ways (priority order):
- Dashboard Settings โ Agents tab with checkboxes for each optional agent
-
Environment Variables โ
AGENT_<NAME>=true/false(e.g.,AGENT_PREDICT_AGENT=false) -
config.yaml โ
agents:section
# config.yaml example
agents:
# Prediction & Analysis
predict_agent: true # ML probability prediction
ai_prediction_filter_agent: true # AI veto mechanism
regime_detector_agent: true # Market state detection
position_analyzer_agent: false # Price position analysis
trigger_detector_agent: true # 5m pattern detection
# Semantic Analysis - LLM variants (expensive, disabled by default)
trend_agent_llm: false # 1h trend LLM analysis
setup_agent_llm: false # 15m setup LLM analysis
trigger_agent_llm: false # 5m trigger LLM analysis
# Semantic Analysis - Local variants (fast, enabled by default)
trend_agent_local: true # 1h trend rule-based analysis
setup_agent_local: true # 15m setup rule-based analysis
trigger_agent_local: true # 5m trigger rule-based analysis
# Reflection
reflection_agent_llm: false # Trade reflection via LLM
reflection_agent_local: true # Trade reflection via rules
# Symbol Selection
symbol_selector_agent: true # AUTO symbol selectionLayer 1: Trend + Fuel (1h EMA + Volume Proxy)
โ PASS/FAIL
Layer 2: AI Filter (PredictAgent direction alignment)
โ PASS/VETO
Layer 3: Setup (15m KDJ + Bollinger Bands entry zone)
โ READY/WAIT
Layer 4: Trigger (5m Pattern + RVOL volume confirmation)
โ CONFIRMED/WAITING
โ
๐ง LLM Decision (DeepSeek Bull/Bear Debate)
โ
๐ก๏ธ Risk Audit (Veto Power)
โ
๐ Execution
๐ See System Architecture Overview section above for visual diagrams.
๐ Mermaid Diagram (Interactive)
graph TB
subgraph "1๏ธโฃ Data Collection Layer"
A["๐ต๏ธ DataSyncAgent<br/>(The Oracle)"] --> MS["MarketSnapshot<br/>5m/15m/1h K-lines"]
end
subgraph "2๏ธโฃ Quant Analysis Layer"
MS --> QA["๐จโ๐ฌ QuantAnalystAgent<br/>(The Strategist)"]
QA --> TS["๐ TrendSubAgent"]
QA --> OS["๐ OscillatorSubAgent"]
QA --> SS["๐น SentimentSubAgent"]
TS & OS & SS --> QR["Quant Signals"]
end
subgraph "3๏ธโฃ Prediction Layer"
MS --> PA["๐ฎ PredictAgent<br/>(The Prophet)"]
PA --> ML["LightGBM Model<br/>Auto-Train 2h"]
ML --> PR["P_Up Prediction"]
end
subgraph "4๏ธโฃ Bull/Bear Adversarial Layer"
MS --> BULL["๐ Bull Agent<br/>(The Optimist)"]
MS --> BEAR["๐ป Bear Agent<br/>(The Pessimist)"]
BULL --> BP["Bull Perspective"]
BEAR --> BRP["Bear Perspective"]
end
subgraph "5๏ธโฃ Reflection Layer"
TH["๐ Trade History<br/>Last 10 Trades"] --> REF["๐ง ReflectionAgent<br/>(The Philosopher)"]
REF --> RI["Reflection Insights<br/>Patterns & Recommendations"]
end
subgraph "6๏ธโฃ Decision Layer"
QR & PR & BP & BRP & RI --> DC["โ๏ธ DecisionCoreAgent<br/>(The Critic)"]
DC --> RD["RegimeDetector"]
DC --> POS["PositionAnalyzer"]
RD & POS --> VR["VoteResult<br/>Action + Confidence"]
end
subgraph "7๏ธโฃ Risk Audit Layer"
VR --> RA["๐ก๏ธ RiskAuditAgent<br/>(The Guardian)"]
RA --> AR["AuditResult<br/>Risk Level + Guard"]
end
subgraph "8๏ธโฃ Execution Layer"
AR --> EE["๐ ExecutionEngine<br/>(The Executor)"]
EE -.->|"Trade Complete"| TH
end
%% Styling for Agent Nodes
style A fill:#4A90E2,color:#fff,stroke:#2563EB,stroke-width:2px
style QA fill:#7ED321,color:#fff,stroke:#059669,stroke-width:2px
style PA fill:#BD10E0,color:#fff,stroke:#9333EA,stroke-width:2px
style BULL fill:#F8E71C,color:#333,stroke:#CA8A04,stroke-width:2px
style BEAR fill:#F8E71C,color:#333,stroke:#CA8A04,stroke-width:2px
style REF fill:#00CED1,color:#fff,stroke:#0891B2,stroke-width:2px
style DC fill:#F5A623,color:#fff,stroke:#EA580C,stroke-width:2px
style RA fill:#D0021B,color:#fff,stroke:#DC2626,stroke-width:2px
style EE fill:#9013FE,color:#fff,stroke:#7C3AED,stroke-width:2px
%% Styling for Output Nodes
style MS fill:#1E3A5F,color:#fff
style QR fill:#1E3A5F,color:#fff
style PR fill:#1E3A5F,color:#fff
style BP fill:#1E3A5F,color:#fff
style BRP fill:#1E3A5F,color:#fff
style RI fill:#1E3A5F,color:#fff
style VR fill:#1E3A5F,color:#fff
style AR fill:#1E3A5F,color:#fff
style TH fill:#1E3A5F,color:#fff๐ Detailed Docs: See Data Flow Analysis for complete mechanisms.
Professional-grade backtesting system for strategy validation before live trading:
Features:
- ๐ Multi-Tab Parallel Backtests: Run up to 5 backtests simultaneously with independent configurations
- ๐ Real-time Progress: Live equity curve, drawdown chart, and trade markers
- ๐ฏ LLM-Enhanced Mode: Test the full multi-agent decision system including DeepSeek analysis
- ๐ Flexible Date Ranges: Quick presets (1/3/7/14/30 days) or custom date selection
- โ๏ธ Advanced Parameters: Configurable leverage, stop-loss, take-profit, and trailing stops
- ๐ Detailed Metrics: Total return, Sharpe/Sortino ratios, win rate, max drawdown, and more
- ๐พ Full Logging: All decisions and LLM interactions saved for analysis
Access: Visit http://localhost:8000/backtest after starting the bot.
The system automatically records intermediate processes for each cycle in the data/ directory, organized by date for easy review and debugging:
data/
โโโ market_data/ # Raw Multi-Timeframe K-Lines
โ โโโ {date}/
โ โโโ BTCUSDT_5m_{timestamp}.json
โ โโโ BTCUSDT_5m_{timestamp}.csv
โ โโโ BTCUSDT_5m_{timestamp}.parquet
โ โโโ BTCUSDT_15m_{timestamp}.json
โ โโโ BTCUSDT_1h_{timestamp}.json
โ
โโโ indicators/ # Full Technical Indicators DataFrames
โ โโโ {date}/
โ โโโ BTCUSDT_5m_{snapshot_id}.parquet
โ โโโ BTCUSDT_15m_{snapshot_id}.parquet
โ โโโ BTCUSDT_1h_{snapshot_id}.parquet
โ
โโโ features/ # Feature Snapshots
โ โโโ {date}/
โ โโโ BTCUSDT_5m_{snapshot_id}_v1.parquet
โ โโโ BTCUSDT_15m_{snapshot_id}_v1.parquet
โ โโโ BTCUSDT_1h_{snapshot_id}_v1.parquet
โ
โโโ context/ # Quant Analysis Summary
โ โโโ {date}/
โ โโโ BTCUSDT_quant_analysis_{snapshot_id}.json
โ
โโโ llm_logs/ # LLM Input Context & Voting Process
โ โโโ {date}/
โ โโโ BTCUSDT_{snapshot_id}.md
โ
โโโ decisions/ # Final Weighted Vote Results
โ โโโ {date}/
โ โโโ BTCUSDT_{snapshot_id}.json
โ
โโโ execution/ # Execution Tracking
โโโ {date}/
โโโ BTCUSDT_{timestamp}.json
- JSON: Human-readable, used for configuration and decision results
- CSV: High compatibility, easy for Excel import
- Parquet: Efficient compression, used for large-scale time-series data
- API Keys: Keep them safe, DO NOT commit to version control.
-
Test First: Use
--testargument to run simulations first. -
Risk Control: Set reasonable stop-loss and position limits in
config.yaml. - Minimal Permissions: Grant only necessary Futures Trading permissions to API keys.
-
Monitoring: Regularly check the
logs/directory for anomalies.
| Document | Description |
|---|---|
| README.md | Project Overview & Quick Start |
| Data Flow Analysis | Complete Data Flow Mechanisms |
| API Key Guide | API Key Configuration Guide |
| Config Example | Trading Parameters Template |
| Env Example | Environment Variables Template |
2026-02-07:
- โ Multi-Agent Chatroom: Per-cycle agent outputs with Decision Core final action.
- โ Agent Config Tabs: Per-agent parameters + optional system prompts in the UI.
- โ LLM Toggle (default off): Enables LLM only when key is provided.
- โ Multi-Period Parser: 1h/15m/5m alignment summarized for Decision Core.
- โ Balance & PnL Fixes: Initial balance fixed, PnL-driven current balance.
2026-01-07:
- โ
AUTO3 Two-Stage Symbol Selection: Enhanced
SymbolSelectorAgentwith two-stage filtering.- Stage 1 (Coarse Filter): 1h backtest on AI500 Top10 + Major coins (~16 symbols) โ Top 5
- Stage 2 (Fine Filter): 15m backtest on Top 5 โ Top 2 performers
- Expanded candidate pool: AI500 (30+ AI/Data coins) + Majors (BTC, ETH, SOL, BNB, XRP, DOGE)
- Auto-refresh every 6 hours with smart caching
- โ
BacktestAgentRunner Parity: Full consistency between backtest and live trading environments.
- Risk Audit Agent integrated into backtest flow
- Four-Layer Strategy Filter applied in backtests
- Position analysis and regime detection enabled
- โ
Enhanced Backtest CLI:
python backtest.pywith support for:- Multi-symbol backtesting
- Agent strategy mode (
--strategy-mode agent) - LLM enhancement option (
--use-llm) - Detailed HTML reports with equity curves
2025-12-31:
- โ
Full Chinese Internationalization (i18n): Complete bilingual support with language toggle button.
- Dashboard UI elements (headers, tables, buttons) fully translated
- Agent documentation sidebar with Chinese descriptions
- Seamless language switching without page reload
2025-12-28:
- โ Dashboard Log Mode Toggle: Switch between Simplified (agent summaries) and Detailed (full debug) log views.
- โ Net Value Curve Enhancement: Smart x-axis labels that adapt to data volume while preserving first cycle timestamp.
2025-12-25:
- โ ReflectionAgent (The Philosopher): New agent that analyzes every 10 trades and provides insights to improve future decisions.
- โ Trading Retrospection: Automatic pattern detection, confidence calibration, and actionable recommendations.
- โ Decision Integration: Reflection insights are injected into Decision Agent prompts for continuous learning.
2025-12-24:
- โ Multi-LLM Support: Added support for 8 LLM providers (DeepSeek, OpenAI, Claude, Qwen, Gemini, Kimi, MiniMax, GLM) with unified interface.
- โ Dashboard LLM Settings: Switch LLM provider and API keys directly from Dashboard Settings.
- โ
Multi-Account Architecture: New
src/exchanges/module withBaseTraderabstraction for multi-exchange support. - โ
Account Manager: Manage multiple trading accounts via Dashboard or
config/accounts.json.
2025-12-21:
- โ
ML Model Upgrade: Upgraded
PredictAgentto use LightGBM machine learning model. - โ Auto-Training: Implemented automatic model retraining every 2 hours to adapt to market drifts.
- โ Dashboard Refinement: Enhanced dashboard with auto-scrolling logs, robust scrollbars, and ML probability display.
2025-12-20:
- โ
Adversarial Decision Framework: Introduced
PositionAnalyzerandRegimeDetector. - โ Confidence Score Refactor: Implemented dynamic confidence penalties.
- โ Full-Link Auditing: Implemented complete intermediate state archiving.
Q: Is this safe to use? Will I lose money? A: Test mode is 100% safe - it uses virtual money. For live trading, only use funds you can afford to lose. Cryptocurrency trading is risky.
Q: Do I need to know Python to use this? A: No! Just follow the Quick Start guide. You only need Python installed, not programming knowledge.
Q: How much money do I need to start? A: Test mode is free. For live trading, minimum $100 USDT recommended, but start small while learning.
Q: Will the bot trade 24/7? A: Yes, once started in continuous mode, it runs non-stop analyzing markets and making decisions.
Q: How do I know if it's working?
A: Open http://localhost:8000 in your browser to see the real-time dashboard with live logs and charts.
Q: Which exchanges are supported? A: Currently only Binance Futures. Spot trading and other exchanges are not supported.
Q: Can I customize the trading strategy?
A: Yes! Edit config.yaml for basic parameters. Advanced users can modify agent logic in src/ directory.
Q: What's the difference between Test and Live mode? A: Test mode simulates trading with $1000 virtual balance. Live mode executes real trades on Binance.
Q: How do I stop the bot?
A: Press Ctrl+C in the terminal, or run pkill -f "python main.py"
Q: Why is the dashboard not loading?
A: Make sure the bot is running and visit http://localhost:8000. Check firewall settings if issues persist.
Q: "ModuleNotFoundError" when starting
A: Run pip install -r requirements.txt to install all dependencies.
Q: "API Key invalid" error
A: Check your .env file has correct Binance API keys. For test mode, API keys are optional.
Q: Bot keeps saying "WAIT" and not trading A: This is normal! The bot is conservative and only trades when conditions are favorable. Check the dashboard logs for reasoning.
Q: How do I update to the latest version?
A: Run git pull origin main then restart the bot.
Issues and Pull Requests are welcome!
This project is licensed under the MIT License. See the LICENSE file for details.
Empowered by AI, Focused on Precision, Starting a New Era of Intelligent Quant! ๐
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for LLM-TradeBot
Similar Open Source Tools
LLM-TradeBot
LLM-TradeBot is an Intelligent Multi-Agent Quantitative Trading Bot based on the Adversarial Decision Framework (ADF). It achieves high win rates and low drawdown in automated futures trading through market regime detection, price position awareness, dynamic score calibration, and multi-layer physical auditing. The bot prioritizes judging 'IF we should trade' before deciding 'HOW to trade' and offers features like multi-agent collaboration, agent configuration, agent chatroom, AUTO1 symbol selection, multi-LLM support, multi-account trading, async concurrency, CLI headless mode, test/live mode toggle, safety mechanisms, and full-link auditing. The system architecture includes a multi-agent architecture with various agents responsible for different tasks, a four-layer strategy filter, and detailed data flow diagrams. The bot also supports backtesting, full-link data auditing, and safety warnings for users.
Lynkr
Lynkr is a self-hosted proxy server that unlocks various AI coding tools like Claude Code CLI, Cursor IDE, and Codex Cli. It supports multiple LLM providers such as Databricks, AWS Bedrock, OpenRouter, Ollama, llama.cpp, Azure OpenAI, Azure Anthropic, OpenAI, and LM Studio. Lynkr offers cost reduction, local/private execution, remote or local connectivity, zero code changes, and enterprise-ready features. It is perfect for developers needing provider flexibility, cost control, self-hosted AI with observability, local model execution, and cost reduction strategies.
pluely
Pluely is a versatile and user-friendly tool for managing tasks and projects. It provides a simple interface for creating, organizing, and tracking tasks, making it easy to stay on top of your work. With features like task prioritization, due date reminders, and collaboration options, Pluely helps individuals and teams streamline their workflow and boost productivity. Whether you're a student juggling assignments, a professional managing multiple projects, or a team coordinating tasks, Pluely is the perfect solution to keep you organized and efficient.
Legacy-Modernization-Agents
Legacy Modernization Agents is an open source migration framework developed to demonstrate AI Agents capabilities for converting legacy COBOL code to Java or C# .NET. The framework uses Microsoft Agent Framework with a dual-API architecture to analyze COBOL code and dependencies, then convert to either Java Quarkus or C# .NET. The web portal provides real-time visualization of migration progress, dependency graphs, and AI-powered Q&A.
tandem
Tandem is a local-first, privacy-focused AI workspace that runs entirely on your machine. It is inspired by early AI coworking research previews, open source, and provider-agnostic. Tandem offers privacy-first operation, provider agnosticism, zero trust model, true cross-platform support, open-source licensing, modern stack, and developer superpowers for everyone. It provides folder-wide intelligence, multi-step automation, visual change review, complete undo, zero telemetry, provider freedom, secure design, cross-platform support, visual permissions, full undo, long-term memory, skills system, document text extraction, workspace Python venv, rich themes, execution planning, auto-updates, multiple specialized agent modes, multi-agent orchestration, project management, and various artifacts and outputs.
botserver
General Bots is a self-hosted AI automation platform and LLM conversational platform focused on convention over configuration and code-less approaches. It serves as the core API server handling LLM orchestration, business logic, database operations, and multi-channel communication. The platform offers features like multi-vendor LLM API, MCP + LLM Tools Generation, Semantic Caching, Web Automation Engine, Enterprise Data Connectors, and Git-like Version Control. It enforces a ZERO TOLERANCE POLICY for code quality and security, with strict guidelines for error handling, performance optimization, and code patterns. The project structure includes modules for core functionalities like Rhai BASIC interpreter, security, shared types, tasks, auto task system, file operations, learning system, and LLM assistance.
mcp-memory-service
The MCP Memory Service is a universal memory service designed for AI assistants, providing semantic memory search and persistent storage. It works with various AI applications and offers fast local search using SQLite-vec and global distribution through Cloudflare. The service supports intelligent memory management, universal compatibility with AI tools, flexible storage options, and is production-ready with cross-platform support and secure connections. Users can store and recall memories, search by tags, check system health, and configure the service for Claude Desktop integration and environment variables.
xln
XLN (Cross-Local Network) is a platform that enables instant off-chain settlement with on-chain finality. It combines Byzantine consensus, Bloomberg Terminal functionalities, and VR capabilities to run economic simulations in the browser without the need for a backend. The architecture includes layers for jurisdictions, entities, and accounts, with features like Solidity contracts, BFT consensus, and bilateral channels. The tool offers a panel system similar to Bloomberg Terminal for workspace organization and visualization, along with support for offline blockchain simulations in the browser and VR/Quest compatibility.
kiss_ai
KISS AI is a lightweight and powerful multi-agent evolutionary framework that simplifies building AI agents. It uses native function calling for efficiency and accuracy, making building AI agents as straightforward as possible. The framework includes features like multi-agent orchestration, agent evolution and optimization, relentless coding agent for long-running tasks, output formatting, trajectory saving and visualization, GEPA for prompt optimization, KISSEvolve for algorithm discovery, self-evolving multi-agent, Docker integration, multiprocessing support, and support for various models from OpenAI, Anthropic, Gemini, Together AI, and OpenRouter.
AutoAgents
AutoAgents is a cutting-edge multi-agent framework built in Rust that enables the creation of intelligent, autonomous agents powered by Large Language Models (LLMs) and Ractor. Designed for performance, safety, and scalability. AutoAgents provides a robust foundation for building complex AI systems that can reason, act, and collaborate. With AutoAgents you can create Cloud Native Agents, Edge Native Agents and Hybrid Models as well. It is so extensible that other ML Models can be used to create complex pipelines using Actor Framework.
Callytics
Callytics is an advanced call analytics solution that leverages speech recognition and large language models (LLMs) technologies to analyze phone conversations from customer service and call centers. By processing both the audio and text of each call, it provides insights such as sentiment analysis, topic detection, conflict detection, profanity word detection, and summary. These cutting-edge techniques help businesses optimize customer interactions, identify areas for improvement, and enhance overall service quality. When an audio file is placed in the .data/input directory, the entire pipeline automatically starts running, and the resulting data is inserted into the database. This is only a v1.1.0 version; many new features will be added, models will be fine-tuned or trained from scratch, and various optimization efforts will be applied.
GitVizz
GitVizz is an AI-powered repository analysis tool that helps developers understand and navigate codebases quickly. It transforms complex code structures into interactive documentation, dependency graphs, and intelligent conversations. With features like interactive dependency graphs, AI-powered code conversations, advanced code visualization, and automatic documentation generation, GitVizz offers instant understanding and insights for any repository. The tool is built with modern technologies like Next.js, FastAPI, and OpenAI, making it scalable and efficient for analyzing large codebases. GitVizz also provides a standalone Python library for core code analysis and dependency graph generation, offering multi-language parsing, AST analysis, dependency graphs, visualizations, and extensibility for custom applications.
OpenOutreach
OpenOutreach is a self-hosted, open-source LinkedIn automation tool designed for B2B lead generation. It automates the entire outreach process in a stealthy, human-like way by discovering and enriching target profiles, ranking profiles using ML for smart prioritization, sending personalized connection requests, following up with custom messages after acceptance, and tracking everything in a built-in CRM with web UI. It offers features like undetectable behavior, fully customizable Python-based campaigns, local execution with CRM, easy deployment with Docker, and AI-ready templating for hyper-personalized messages.
vibe-remote
Vibe Remote is a tool that allows developers to code using AI agents through Slack or Discord, eliminating the need for a laptop or IDE. It provides a seamless experience for coding tasks, enabling users to interact with AI agents in real-time, delegate tasks, and monitor progress. The tool supports multiple coding agents, offers a setup wizard for easy installation, and ensures security by running locally on the user's machine. Vibe Remote enhances productivity by reducing context-switching and enabling parallel task execution within isolated workspaces.
ClaraVerse
ClaraVerse is a privacy-first AI assistant and agent builder that allows users to chat with AI, create intelligent agents, and turn them into fully functional apps. It operates entirely on open-source models running on the user's device, ensuring data privacy and security. With features like AI assistant, image generation, intelligent agent builder, and image gallery, ClaraVerse offers a versatile platform for AI interaction and app development. Users can install ClaraVerse through Docker, native desktop apps, or the web version, with detailed instructions provided for each option. The tool is designed to empower users with control over their AI stack and leverage community-driven innovations for AI development.
For similar tasks
FinRobot
FinRobot is an open-source AI agent platform designed for financial applications using large language models. It transcends the scope of FinGPT, offering a comprehensive solution that integrates a diverse array of AI technologies. The platform's versatility and adaptability cater to the multifaceted needs of the financial industry. FinRobot's ecosystem is organized into four layers, including Financial AI Agents Layer, Financial LLMs Algorithms Layer, LLMOps and DataOps Layers, and Multi-source LLM Foundation Models Layer. The platform's agent workflow involves Perception, Brain, and Action modules to capture, process, and execute financial data and insights. The Smart Scheduler optimizes model diversity and selection for tasks, managed by components like Director Agent, Agent Registration, Agent Adaptor, and Task Manager. The tool provides a structured file organization with subfolders for agents, data sources, and functional modules, along with installation instructions and hands-on tutorials.
AirdropsBot2024
AirdropsBot2024 is an efficient and secure solution for automated trading and sniping of coins on the Solana blockchain. It supports multiple chain networks such as Solana, BTC, and Ethereum. The bot utilizes premium APIs and Chromedriver to automate trading operations through web interfaces of popular exchanges. It offers high-speed data analysis, in-depth market analysis, support for major exchanges, complete security and control, data visualization, advanced notification options, flexibility and adaptability in trading strategies, and profile management.
gpt-bitcoin
The gpt-bitcoin repository is focused on creating an automated trading system for Bitcoin using GPT AI technology. It provides different versions of trading strategies utilizing various data sources such as OHLCV, Moving Averages, RSI, Stochastic Oscillator, MACD, Bollinger Bands, Orderbook Data, news data, fear/greed index, and chart images. Users can set up the system by creating a .env file with necessary API keys and installing required dependencies. The repository also includes instructions for setting up the environment on local machines and AWS EC2 Ubuntu servers. The future plan includes expanding the system to support other cryptocurrency exchanges like Bithumb, Binance, Coinbase, OKX, and Bybit.
ai-hedge-fund
AI Hedge Fund is a proof of concept for an AI-powered hedge fund that explores the use of AI to make trading decisions. The project is for educational purposes only and simulates trading decisions without actual trading. It employs agents like Market Data Analyst, Valuation Agent, Sentiment Agent, Fundamentals Agent, Technical Analyst, Risk Manager, and Portfolio Manager to gather and analyze data, calculate risk metrics, and make trading decisions.
PredictorLLM
PredictorLLM is an advanced trading agent framework that utilizes large language models to automate trading in financial markets. It includes a profiling module to establish agent characteristics, a layered memory module for retaining and prioritizing financial data, and a decision-making module to convert insights into trading strategies. The framework mimics professional traders' behavior, surpassing human limitations in data processing and continuously evolving to adapt to market conditions for superior investment outcomes.
tradecat
TradeCat is a comprehensive data analysis and trading platform designed for cryptocurrency, stock, and macroeconomic data. It offers a wide range of features including multi-market data collection, technical indicator modules, AI analysis, signal detection engine, Telegram bot integration, and more. The platform utilizes technologies like Python, TimescaleDB, TA-Lib, Pandas, NumPy, and various APIs to provide users with valuable insights and tools for trading decisions. With a modular architecture and detailed documentation, TradeCat aims to empower users in making informed trading decisions across different markets.
OpenAlice
Open Alice is an AI trading agent that provides users with their own research desk, quant team, trading floor, and risk management, all running on their laptop 24/7. It is file-driven, reasoning-driven, and OS-native, allowing interactions with the operating system. Features include dual AI providers, crypto trading, securities trading, market analysis, cognitive state, event log, cron scheduling, evolution mode, and a web UI. The architecture includes providers, core components, extensions, tasks, and interfaces. Users can quickly start by setting up prerequisites, AI providers, crypto trading, securities trading, environment variables, and running the tool. Configuration files, project structure, and license information are also provided.
LLM-TradeBot
LLM-TradeBot is an Intelligent Multi-Agent Quantitative Trading Bot based on the Adversarial Decision Framework (ADF). It achieves high win rates and low drawdown in automated futures trading through market regime detection, price position awareness, dynamic score calibration, and multi-layer physical auditing. The bot prioritizes judging 'IF we should trade' before deciding 'HOW to trade' and offers features like multi-agent collaboration, agent configuration, agent chatroom, AUTO1 symbol selection, multi-LLM support, multi-account trading, async concurrency, CLI headless mode, test/live mode toggle, safety mechanisms, and full-link auditing. The system architecture includes a multi-agent architecture with various agents responsible for different tasks, a four-layer strategy filter, and detailed data flow diagrams. The bot also supports backtesting, full-link data auditing, and safety warnings for users.
For similar jobs
qlib
Qlib is an open-source, AI-oriented quantitative investment platform that supports diverse machine learning modeling paradigms, including supervised learning, market dynamics modeling, and reinforcement learning. It covers the entire chain of quantitative investment, from alpha seeking to order execution. The platform empowers researchers to explore ideas and implement productions using AI technologies in quantitative investment. Qlib collaboratively solves key challenges in quantitative investment by releasing state-of-the-art research works in various paradigms. It provides a full ML pipeline for data processing, model training, and back-testing, enabling users to perform tasks such as forecasting market patterns, adapting to market dynamics, and modeling continuous investment decisions.
jupyter-quant
Jupyter Quant is a dockerized environment tailored for quantitative research, equipped with essential tools like statsmodels, pymc, arch, py_vollib, zipline-reloaded, PyPortfolioOpt, numpy, pandas, sci-py, scikit-learn, yellowbricks, shap, optuna, ib_insync, Cython, Numba, bottleneck, numexpr, jedi language server, jupyterlab-lsp, black, isort, and more. It does not include conda/mamba and relies on pip for package installation. The image is optimized for size, includes common command line utilities, supports apt cache, and allows for the installation of additional packages. It is designed for ephemeral containers, ensuring data persistence, and offers volumes for data, configuration, and notebooks. Common tasks include setting up the server, managing configurations, setting passwords, listing installed packages, passing parameters to jupyter-lab, running commands in the container, building wheels outside the container, installing dotfiles and SSH keys, and creating SSH tunnels.
FinRobot
FinRobot is an open-source AI agent platform designed for financial applications using large language models. It transcends the scope of FinGPT, offering a comprehensive solution that integrates a diverse array of AI technologies. The platform's versatility and adaptability cater to the multifaceted needs of the financial industry. FinRobot's ecosystem is organized into four layers, including Financial AI Agents Layer, Financial LLMs Algorithms Layer, LLMOps and DataOps Layers, and Multi-source LLM Foundation Models Layer. The platform's agent workflow involves Perception, Brain, and Action modules to capture, process, and execute financial data and insights. The Smart Scheduler optimizes model diversity and selection for tasks, managed by components like Director Agent, Agent Registration, Agent Adaptor, and Task Manager. The tool provides a structured file organization with subfolders for agents, data sources, and functional modules, along with installation instructions and hands-on tutorials.
hands-on-lab-neo4j-and-vertex-ai
This repository provides a hands-on lab for learning about Neo4j and Google Cloud Vertex AI. It is intended for data scientists and data engineers to deploy Neo4j and Vertex AI in a Google Cloud account, work with real-world datasets, apply generative AI, build a chatbot over a knowledge graph, and use vector search and index functionality for semantic search. The lab focuses on analyzing quarterly filings of asset managers with $100m+ assets under management, exploring relationships using Neo4j Browser and Cypher query language, and discussing potential applications in capital markets such as algorithmic trading and securities master data management.
jupyter-quant
Jupyter Quant is a dockerized environment tailored for quantitative research, equipped with essential tools like statsmodels, pymc, arch, py_vollib, zipline-reloaded, PyPortfolioOpt, numpy, pandas, sci-py, scikit-learn, yellowbricks, shap, optuna, and more. It provides Interactive Broker connectivity via ib_async and includes major Python packages for statistical and time series analysis. The image is optimized for size, includes jedi language server, jupyterlab-lsp, and common command line utilities. Users can install new packages with sudo, leverage apt cache, and bring their own dot files and SSH keys. The tool is designed for ephemeral containers, ensuring data persistence and flexibility for quantitative analysis tasks.
Qbot
Qbot is an AI-oriented automated quantitative investment platform that supports diverse machine learning modeling paradigms, including supervised learning, market dynamics modeling, and reinforcement learning. It provides a full closed-loop process from data acquisition, strategy development, backtesting, simulation trading to live trading. The platform emphasizes AI strategies such as machine learning, reinforcement learning, and deep learning, combined with multi-factor models to enhance returns. Users with some Python knowledge and trading experience can easily utilize the platform to address trading pain points and gaps in the market.
FinMem-LLM-StockTrading
This repository contains the Python source code for FINMEM, a Performance-Enhanced Large Language Model Trading Agent with Layered Memory and Character Design. It introduces FinMem, a novel LLM-based agent framework devised for financial decision-making, encompassing three core modules: Profiling, Memory with layered processing, and Decision-making. FinMem's memory module aligns closely with the cognitive structure of human traders, offering robust interpretability and real-time tuning. The framework enables the agent to self-evolve its professional knowledge, react agilely to new investment cues, and continuously refine trading decisions in the volatile financial environment. It presents a cutting-edge LLM agent framework for automated trading, boosting cumulative investment returns.
LLMs-in-Finance
This repository focuses on the application of Large Language Models (LLMs) in the field of finance. It provides insights and knowledge about how LLMs can be utilized in various scenarios within the finance industry, particularly in generating AI agents. The repository aims to explore the potential of LLMs to enhance financial processes and decision-making through the use of advanced natural language processing techniques.


