🚀 Quantitative Trading System

A comprehensive quantitative trading system with AI-powered analysis, real-time data processing, and advanced risk management

📋 Table of Contents

• Overview
• Features
• Architecture
• Quick Start
• Installation
• Usage Examples
• Documentation
• Contributing
• License

🎯 Overview

This is a production-ready quantitative trading system that combines traditional financial analysis with cutting-edge AI/ML technologies. The system provides a complete pipeline from data collection to strategy execution, featuring real-time market data processing, advanced factor analysis, AI-powered sentiment analysis, and comprehensive risk management.

🌟 Key Highlights

• 🔬 Advanced Factor Analysis: Multi-factor models with momentum, value, quality, and volatility factors
• 🤖 AI/LLM Integration: OpenAI GPT integration for market analysis and strategy recommendations
• 📊 Real-time Data: WebSocket-based real-time market data from multiple exchanges
• 🎯 Strategy Framework: Extensible strategy system with 8+ built-in quantitative strategies
• ⚡ High Performance: C++ core engine for low-latency order execution
• 📈 Visualization: Interactive dashboards with Plotly and Streamlit
• 🛡️ Risk Management: Comprehensive risk controls and portfolio management

✨ Features

📊 Data Management

• Multi-source Data: Binance, Yahoo Finance, Alpha Vantage
• Real-time Streaming: WebSocket connections for live market data
• Data Processing: Automated data cleaning and feature engineering
• Storage: SQLite, PostgreSQL, and Redis caching support

🧠 AI & Machine Learning

• LLM Integration: OpenAI GPT for market analysis and insights
• NLP Processing: Sentiment analysis of news and social media
• ML Models: XGBoost, Random Forest, Neural Networks
• Feature Engineering: Technical indicators and statistical features

📈 Quantitative Analysis

• Factor Models: Momentum, Value, Quality, Size, Volatility factors
• Stock Screening: Multi-factor stock selection and filtering
• Portfolio Optimization: Risk parity and mean-variance optimization
• Performance Analysis: Comprehensive backtesting and metrics

🎮 Strategy Framework

• Extensible Design: Easy to add custom strategies
• Built-in Strategies: 8+ proven quantitative strategies
• Strategy Registry: Centralized strategy management
• Parameter Optimization: Automated strategy optimization

🛡️ Risk Management

• Position Sizing: Dynamic position sizing algorithms
• Risk Limits: VaR, CVaR, drawdown, and leverage limits
• Portfolio Management: Real-time portfolio monitoring
• Alert System: Price and risk alerts

🖥️ User Interfaces

• Web Dashboard: FastAPI-based web interface
• Streamlit App: Interactive data science dashboard
• Real-time Charts: K-line charts with technical indicators
• Mobile Friendly: Responsive design for all devices

🏗️ Architecture

┌─────────────────────────────────────────────────────────────┐
│                    Python Layer (data_service/)             │
├─────────────────────────────────────────────────────────────┤
│  • Data Fetchers     • Strategy Framework    • AI/ML       │
│  • Factor Analysis   • Backtesting Engine    • Visualization│
│  • Storage Layer     • Real-time Data        • Web UI      │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                    C++ Core Engine (backend/)               │
├─────────────────────────────────────────────────────────────┤
│  • Order Execution   • Risk Management       • Portfolio   │
│  • Data Loading      • Strategy Engine       • Performance │
└─────────────────────────────────────────────────────────────┘

🚀 Quick Start

1. Clone the Repository

git clone https://github.com/yourusername/tradingsystem.git
cd tradingsystem

2. Install Dependencies

# Install all features
pip install -e .[ai,visualization,realtime,web]

# Or install specific features
pip install -e .[ai]           # AI/ML features
pip install -e .[visualization] # Charts and dashboards
pip install -e .[realtime]      # Real-time data
pip install -e .[web]          # Web interface

3. Run Basic Example

# Test data fetching (no API keys required)
python examples/fetch_public_data.py

4. Launch Dashboard

# Start Streamlit dashboard
python run_dashboard.py
# Visit: http://localhost:8501

# Or start web interface
python run_web_interface.py
# Visit: http://localhost:8000

📦 Installation

Prerequisites

• Python 3.8+
• C++17 compatible compiler (for backend)
• CMake 3.12+ (for backend)

Full Installation

# 1. Clone repository
git clone https://github.com/yourusername/tradingsystem.git
cd tradingsystem

# 2. Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# 3. Install Python dependencies
pip install -e .[ai,visualization,realtime,web]

# 4. Build C++ backend (optional)
cd backend
mkdir build && cd build
cmake ..
make -j4
cd ../..

# 5. Configure API keys (optional)
cp config.example.json config.json
# Edit config.json with your API keys

API Keys (Optional)

For full functionality, you can add API keys to config.json:

{
  "binance": {
    "api_key": "your_binance_api_key",
    "secret_key": "your_binance_secret"
  },
  "openai": {
    "api_key": "your_openai_api_key"
  },
  "alpha_vantage": {
    "api_key": "your_alpha_vantage_key"
  }
}

💡 Usage Examples

Basic Data Fetching

from data_service.fetchers import BinanceFetcher

# Get cryptocurrency data (no API key required)
fetcher = BinanceFetcher()
btc_price = fetcher.get_current_price("BTCUSD")
print(f"BTC Price: ${btc_price:,.2f}")

Factor Analysis

from data_service.factors import FactorCalculator, FactorScreener

# Calculate factors
calculator = FactorCalculator()
factors = calculator.calculate_all_factors(symbol, prices, volumes)

# Screen stocks
screener = FactorScreener()
results = screener.create_momentum_screener().screen_stocks(factor_data)

Strategy Backtesting

from data_service.backtest import BacktestEngine
from data_service.strategies import MomentumStrategy

# Run backtest
engine = BacktestEngine(initial_capital=100000)
strategy = MomentumStrategy()
results = engine.run_backtest(strategy, historical_data)

AI-Powered Analysis

from data_service.ai import LLMIntegration

# Get AI insights
llm = LLMIntegration(provider="openai")
analysis = llm.analyze_market(factor_data, price_data)
print(f"AI Recommendation: {analysis.content}")

📚 Documentation

Module Documentation

• 📊 Factor Analysis - Multi-factor models and stock screening
• 🤖 AI & LLM Integration - AI-powered market analysis
• 🎯 Quantitative Strategies - Trading strategies guide
• 🌐 Web Interface - Web dashboard usage
• 🔗 LangChain Integration - Advanced LLM features

Examples

• examples/fetch_public_data.py - Basic data fetching
• examples/quantitative_strategies.py - Strategy examples
• examples/factor_analysis_demo.py - Factor analysis demo
• examples/llm_nlp_complete_demo.py - AI features demo

🧪 Testing

# Run all tests
pytest tests/ -v

# Run specific test modules
pytest tests/test_data_processor.py -v
pytest tests/test_llm_integration.py -v

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Setup

# Install development dependencies
pip install -e .[test,dev]

# Run tests
pytest tests/ -v

# Run linting
flake8 data_service/
black data_service/

Code Style

• Follow PEP 8 for Python code
• Use type hints
• Add docstrings for all functions
• Write tests for new features

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

⚠️ Disclaimer

This software is for educational and research purposes only. Trading involves substantial risk of loss and is not suitable for all investors. Past performance does not guarantee future results. Please consult with a financial advisor before making any investment decisions.

🙏 Acknowledgments

• Binance API for cryptocurrency data
• Yahoo Finance for stock market data
• OpenAI for AI capabilities
• Streamlit for dashboard framework
• FastAPI for web framework

Made with ❤️ by the Quantitative Trading Community