Lean Allinone

An all-in-one Docker image for the QuantConnect Lean algorithmic trading engine, supporting automatic GPU selection, a modern web interface, REST API, and MCP protocol integration

Finance Developer tools #Algorithmic Trading #GPU Acceleration #Docker Image #MCP Integration .Python

rating : 2.5 points

downloads : 6.7K

update time : 2026-03-13

Open Site

What is Lean Engine All-in-One?

Lean Engine All-in-One is a complete solution integrating the QuantConnect Lean quantitative trading engine, providing an out-of-the-box quantitative trading development environment through Docker containers. It packages the trading engine, web interface, API services, and AI integration capabilities into a single container, allowing users to start quantitative strategy development and backtesting without complex configuration.

How to use Lean Engine All-in-One?

Simply run a Docker command, and the system will automatically start all services. You can access the modern web interface through a browser to manage strategies, perform programmatic operations through the REST API, or integrate with an AI assistant via the MCP protocol. The system also supports automatic GPU selection to optimize computing performance.

Applicable Scenarios

Suitable for quantitative trading developers, fintech teams, educational institutions, and researchers. Whether it's individual strategy development, team collaborative research, or teaching demonstrations, it can provide a complete solution. It is particularly suitable for scenarios that require quickly setting up a quantitative trading environment.

Main Features

Intelligent GPU Selection

Automatically detect and select the GPU with the lowest memory usage, optimize computing resource allocation, and improve backtesting performance.

Modern Web Interface

Responsive design, supporting dark mode and multiple languages (English/Chinese/Japanese), providing an intuitive strategy management and result viewing experience.

REST API Service

A complete API based on FastAPI, supporting Swagger documentation, facilitating programmatic management and integration.

MCP AI Integration

Supports the Model Context Protocol, enabling seamless integration with AI assistants (such as Claude), and operating the quantitative trading system through natural language.

Real-time Monitoring

Real-time push of GPU status and backtesting progress through WebSocket to keep track of the system's operating status at any time.

Integrated Deployment

A single container contains all components: nginx, API services, and MCP services, simplifying deployment and maintenance.

Advantages

Out-of-the-box: No complex configuration is required. A single command can start the complete system.

Performance optimization: Automatic GPU selection and CUDA support improve computing efficiency.

Multilingual support: The interface supports three languages: English, Chinese, and Japanese, suitable for international teams.

AI-friendly: The MCP protocol allows AI assistants to directly operate the system.

Simple deployment: Docker containerization supports various cloud environments and local deployment.

Real-time feedback: Real-time monitoring via WebSocket to keep informed of the system status in a timely manner.

Limitations

Hardware requirements: An NVIDIA GPU supporting CUDA is required for optimal performance.

Learning curve: Basic Docker knowledge is needed for deployment and management.

Resource consumption: The complete system requires a certain amount of memory and storage space.

Network dependency: Some functions require an internet connection to download data.

Customization limitations: The pre-configured environment may not meet highly customized requirements.

How to Use

Install Docker and NVIDIA Drivers

Ensure that Docker and the NVIDIA Container Toolkit are installed on the system, and the GPU driver supports CUDA.

Pull and Run the Image

Use Docker commands to start the Lean Engine container and map the necessary ports.

Access the Web Interface

Open http://localhost:8280 in a browser to access the web management interface.

Configure the Data Directory (Optional)

Mount a local directory to persist data and strategy files.

Use Docker Compose (Recommended)

Use the docker-compose.yml file for more complex configuration and management.

Usage Examples

Individual Strategy Development

Individual developers can use the web interface to quickly develop and test trading strategies without building a complex environment.

Team Collaborative Research

Research teams can share the same environment and use the API to automatically execute batch backtesting and parameter optimization.

AI-assisted Quantitative Analysis

Use the MCP protocol to let an AI assistant help analyze strategies, optimize parameters, and interpret backtesting results.

Teaching Demonstration Environment

Educational institutions can provide students with a unified quantitative trading experiment environment, avoiding environment configuration issues.

Frequently Asked Questions

What kind of hardware configuration is required?

How to import my own strategies?

What data sources are supported?

How to back up data and results?

Can multiple backtests be run simultaneously?

How to update to the latest version?

Are Chinese strategy names and comments supported?

How to monitor the system resource usage?

Related Resources

Docker Hub Image Page

The official Docker image repository to view the latest version and download statistics.

GitHub Project Homepage

Project source code and issue tracking.

QuantConnect Lean Documentation

Official documentation for the underlying Lean engine.

FastAPI Documentation

Detailed documentation for the REST API framework.

Model Context Protocol Specification

Official specification and examples of the MCP protocol.

NVIDIA CUDA Toolkit

Download the CUDA toolkit required for GPU computing.

Docker Official Documentation

A complete guide to Docker usage and management.

🚀 Lean Engine All-in-One

All-in-One Docker image for QuantConnect Lean algorithmic trading engine with GPU support, modern Web UI, REST API, and MCP integration.

English | Simplified Chinese | Traditional Chinese | Japanese

✨ Features

🎯 GPU Auto-Selection: Automatically selects the GPU with the lowest memory usage.
🌐 Modern Web UI: Responsive design with dark mode and i18n (EN/ZH/JA).
🔌 REST API: FastAPI with Swagger docs available at /docs.
🤖 MCP Server: Model Context Protocol for AI integration.
📊 Real-time Monitoring: Monitor GPU status and backtest progress via WebSocket.
🐳 All-in-One: A single container that includes nginx, API, and MCP services.

🚀 Quick Start

docker run -d --gpus all \
  -p 8280:80 -p 8281:8000 -p 8282:8001 \
  --name lean-engine \
  neosun/lean:latest

Access the following:

Web UI: http://localhost:8280
API Docs: http://localhost:8281/docs
Health Check: http://localhost:8281/health

📦 Installation

Docker Compose (Recommended)

services:
  lean:
    image: neosun/lean:latest
    container_name: lean-engine
    restart: unless-stopped
    ports:
      - "8280:80"      # Web UI
      - "8281:8000"    # REST API
      - "8282:8001"    # MCP Server
    volumes:
      - ./data:/Lean/Data
      - ./results:/Lean/Results
      - ./algorithms:/Lean/Algorithms
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

docker compose up -d

⚙️ Configuration

Property	Details
`MODE`	Default: `all`. Service mode options: `ui`, `api`, `mcp`, `all`
`GPU_AUTO_SELECT`	Default: `true`. Auto-select the GPU with the lowest memory.
`API_HOST`	Default: `0.0.0.0`. API bind address.
`API_PORT`	Default: `8000`. API port.
`MCP_HOST`	Default: `0.0.0.0`. MCP bind address.
`MCP_PORT`	Default: `8001`. MCP port.

🔌 API Endpoints

Endpoint	Method	Description
`/health`	GET	Health check
`/api/gpu/status`	GET	GPU status
`/api/gpu/select`	POST	Select a GPU
`/api/algorithms`	GET	List algorithms
`/api/backtest`	POST	Run a backtest
`/api/jobs`	GET	List jobs
`/api/results/{id}`	GET	Get results
`/ws`	WS	WebSocket for real-time updates

🤖 MCP Tools

Tool	Description
`gpu_status`	Get GPU information
`gpu_select`	Select a specific GPU
`list_algorithms`	List available algorithms
`run_backtest`	Execute a backtest
`get_results`	Retrieve backtest results

📁 Project Structure

docker/
├── Dockerfile           # Multi-stage build
├── docker-compose.yml   # Compose configuration
├── nginx.conf           # Reverse proxy config
├── supervisord.conf     # Process manager
├── app/
│   ├── api_server.py    # FastAPI REST API
│   ├── mcp_server.py    # MCP Server
│   ├── gpu_manager.py   # GPU auto-selection
│   └── static/
│       └── index.html   # Web UI
└── .env.example         # Environment template