An AI-powered quantitative trading platform for cryptocurrencies, stocks, and FX with backtesting, live trading, market data, and multi-agent research. vibe-trading,trading-agents,ai-trader,ai-trading

---

Contents

Quick Start · Repositories · Artificial Intelligence Agent and MCP · Overview · Features · Visual Navigation · Architecture · Install · Docs · FAQ · License

---

Quantitative Dingle is a self-hosted, native-first quant platform: AI-assisted research , Python-native strategy , backtesting , and real-time trading (cryptocurrencies, IBKR stocks, MT5 FX) all rolled into one product - rather than a loose collection of scripts and SaaS tabs.

Try again in two minutes

Prerequisites: Docker with Compose (Docker Desktop on Windows/macOS or Docker Engine + Compose plugin on Linux), and Git . Node.js is not required (prebuilt UI is in frontend/dist ).

macOS/Linux (Bash)

One line (or the same steps separately):

 If git clone https://github.com/brokermr810/QuantDinger.git && cd QuantDinger && cp backend_api_python/env.example backend_api_python/.env && chmod +x scripts/generate-secret-key.sh && ./scripts/generate-secret-key.sh && docker-compose up -d --build

./scripts/generate-secret-key.sh fails with “Permission denied”, run chmod +x scripts/generate-secret-key.sh and retry. If docker-compose is not found, try docker compose (Compose V2).

Windows(PowerShell)

Use PowerShell (not CMD) into the folder where you want the project. Docker Desktop must be running (WSL2 backend recommended).

 git clone https://github.com/brokermr810/QuantDinger.git Set-Location QuantDinger Copy-Item backend_api_python\env.example -Destination backend_api_python\.env $key = & python -c "import secrets; print(secrets.token_hex(32))" 2>$null if (-not $key) { $key = & py -c "import secrets; print(secrets.token_hex(32))" 2>$null } if (-not $key) { $key = & python3 -c "import secrets; print(secrets.token_hex(32))" 2>$null } if (-not $key) { Write-Error "Install Python 3 from python.org (tick 'Add to PATH') or use Git Bash with the macOS/Linux block above." } (Get-Content backend_api_python\.env) -replace '^SECRET_KEY=.*$', "SECRET_KEY=$key" | Set-Content backend_api_python\.env -Encoding utf8 docker-compose up -d --build If git clone https://github.com/brokermr810/QuantDinger.git Set-Location QuantDinger Copy-Item backend_api_python\env.example -Destination backend_api_python\.env $key = & python -c "import secrets; print(secrets.token_hex(32))" 2>$null if (-not $key) { $key = & py -c "import secrets; print(secrets.token_hex(32))" 2>$null } if (-not $key) { $key = & python3 -c "import secrets; print(secrets.token_hex(32))" 2>$null } if (-not $key) { Write-Error "Install Python 3 from python.org (tick 'Add to PATH') or use Git Bash with the macOS/Linux block above." } (Get-Content backend_api_python\.env) -replace '^SECRET_KEY=.*$', "SECRET_KEY=$key" | Set-Content backend_api_python\.env -Encoding utf8 docker-compose up -d --build

docker-compose is not recognized, use docker compose (spaces, no hyphens) If Git is missing, install Git for Windows .

Windows Alternative: Git Bash

If you have Git for Windows installed, open Git Bash and you can use the macOS / Linux one-liner above (Bash + chmod + ./scripts/generate-secret-key.sh ).

---

Then open http://localhost:8888 , log in to quantdinger / 123456 , and change the default administrator password before actually using it. For prerequisites, configuration details, first-run checks, and troubleshooting, see Installation and First-Time Installation below.

Related warehouses

This single repository ships backend , Docker composition stack, documentation , and a prebuilt web UI under frontend/dist . Use the sibling repos when you need source-level UI changes or the mobile app:

Repository	what is
QuantDinger (this repo)	Backend (Flask/Python), deployment, documentation, bundled web resources
QuantDinger-Vue	Web front-end source (Vue)—themes, forks, npm run build → replace frontend/dist
QuantDinger-Mobile	Open source mobile client – ​​pair with your self-hosted or SaaS backend

Note: Node.js only requires QuantDinger-Vue if you build from the Web UI; the default Docker quickstart does not require it.

Used from the AI ​​agent (Cursor/Claude Code/Codex/MCP).

Quantum transport agent gateway at /api/agent/v1 and a small MCP server which wraps it into a model context protocol tool. Once you log in once and issue tokens, your AI client can read the market, manage strategies, perform backtests, and (paper only by default) place trades - and you never see your exchange keys or admin JWTs.

There are two security properties that are non-negotiable: Every customer service call is audit-logged , and transaction tokens are paper-only by default . Live execution requires both paper_only=false on the token AND AGENT_LIVE_TRADING_ENABLED=true on the server.

Step One — Obtain Agent Tokens (Two paths, your choice)

The MCP client and the wiring in step 2 are identical for both paths — only the value of QUANTDINGER_BASE_URL changes.

Path A · Moderator ( ai.quantdinger.com ) – Try it for 30 seconds. Register → Open Sidebar → Agent Token → Issue Token . The hosted instance is locked to paper_only=true and the T (Trading) scope is rejected at issuance — agents can read markets, manage strategies in your tenant, and run backtests, but never route real-money orders. Set QUANTDINGER_BASE_URL=https://ai.quantdinger.com . Best for: trying QuantDinger from Cursor / Claude Code without installing anything; demos; research notebooks against shared datasets. Path B · Self-hosting (this warehouse) - production/private data/real-time transactions. Try Docker startup again after two minutes , log in as administrator and open the sidebar → Agent Tokens (or QUANTDINGER_BASE_URL=http://localhost:8888 :8888/ # http://localhost:8888/#/agent-tokens ). AGENT_LIVE_TRADING_ENABLED=true decide scopes (incl. LAN URL). Best for: anyone with their own exchange keys, anyone with private strategies/data, teams behind a VPN, or anyone who eventually wants live execution.

No matter which way:

1. Click issues token → name it ( cursor-mcp , claude-research , …).
2. Select Telescope - Start with R + B (reading + backtesting); add W to let the agent create/edit the strategy on its own.
3. Copy token once - the conversation displays the entire string only once; the server only retains a SHA-256 hash.

Prefer CLI? See docs/agent/AGENT_QUICKSTART.md for the equivalent curl .

Step 2 — Connect the MCP server to your AI client

The MCP server is located at mcp_server/ . Both transports are available everywhere:

A: Local standards (cursor, Claude Code, Codex desktop, etc.) - the server is published on PyPI as quantdinger-mcp . Drop this into .cursor/mcp.json , ~/.config/claude/claude_desktop_config.json , or your client's equivalent (template: docs/agent/cursor-mcp.example.json ):

 { "mcpServers": { "quantdinger": { "command": "uvx", "args": ["quantdinger-mcp"], "env": { "QUANTDINGER_BASE_URL": "http://localhost:8888", "QUANTDINGER_AGENT_TOKEN": "qd_agent_xxxxxxxx" } } } } uvx { "mcpServers": { "quantdinger": { "command": "uvx", "args": ["quantdinger-mcp"], "env": { "QUANTDINGER_BASE_URL": "http://localhost:8888", "QUANTDINGER_AGENT_TOKEN": "qd_agent_xxxxxxxx" } } } }

( Install UV ) downloads + caches the package on first run; no virtualenv setup. If you prefer pip:

 pip install quantdinger-mcp # then use {"command": "quantdinger-mcp", "args": []} For Claude Code's CLI assistant: pip install quantdinger-mcp # then use {"command": "quantdinger-mcp", "args": []}

claude mcp add quantdinger \ --env QUANTDINGER_BASE_URL=http://localhost:8888 \ --env QUANTDINGER_AGENT_TOKEN=qd_agent_xxxxxxxx \ -- uvx quantdinger-mcp B. Remote HTTP (cloud proxies such as OpenClaw/NanoBot, browser IDE, any software that cannot generate child processes) claude mcp add quantdinger \ --env QUANTDINGER_BASE_URL=http://localhost:8888 \ --env QUANTDINGER_AGENT_TOKEN=qd_agent_xxxxxxxx \ -- uvx quantdinger-mcp

— run the MCP server as a long-lived service, then point clients at the URL:

 QUANTDINGER_BASE_URL=https://your-host \ QUANTDINGER_AGENT_TOKEN=qd_agent_xxxxxxxx \ QUANTDINGER_MCP_TRANSPORT=streamable-http \ QUANTDINGER_MCP_HOST=0.0.0.0 \ QUANTDINGER_MCP_PORT=7800 \ quantdinger-mcp # clients connect to http://your-host:7800 Use QUANTDINGER_BASE_URL=https://your-host \ QUANTDINGER_AGENT_TOKEN=qd_agent_xxxxxxxx \ QUANTDINGER_MCP_TRANSPORT=streamable-http \ QUANTDINGER_MCP_HOST=0.0.0.0 \ QUANTDINGER_MCP_PORT=7800 \ quantdinger-mcp # clients connect to http://your-host:7800

QUANTDINGER_MCP_TRANSPORT=sse instead for clients that only speak the older SSE transport. Put a reverse proxy in front for TLS and IP allowlisting.

Step 3 – Talk to your agent

Restart the IDE and ask questions like:

• “Pull the last 90 daily candles, BTC/USDT, and tell me what the regime detector shows.”
• "Between 2024-01-01 and 2024-06-30, backtest the 20/60 moving average crossover on ETH/USDT for 4 hours, and live broadcast during the operation."
• "Develop a tool called eth-trend-bot , use the indicator I just designed, leave it in stopped state."

Long-running jobs ( /api/agent/v1/jobs/{id}/stream ) are exposed as SSE so the agent can react to partial results without polling. Every call shows up under agent token → Audit log includes route, scope category, status code and duration.

Want to use QuantDinger as a coding and agent background?

If you edit this repository with Cursor/Claude Code/Codex, the repository also comes with a Cursor Skills.cursor .cursor/skills/quantdinger-agent-workflow/SKILL.md which explains the proxy gateway internals, redlining (no real keys, only paper keys by default) and where to verify changes. Read docs/agent/AGENT_ENVIRONMENT_DESIGN.md for the complete layered contract model.

Further links: Artificial Intelligence Integrated Design · Quickstart with curl · OpenAPI 3.0 Specification · MCP Server README

Product overview

Quantitative Dingle is a self-hosted quantitative operating system: AI-assisted research , Python native strategy ( IndicatorStrategy + ScriptStrategy ), backtesting , and real-time trading (cryptocurrencies, IBKR, MT5) - with optional multi-user roles, notifications, credits and USDT billing. It replaces the cobbled-together version with diagrams, notebooks, bots, and disconnected large language model chat with a Compose stack and your credentials in Postgres + .env .

Typical DIY stack	QuantDinger
Chat AI, independent of execution	Analysis, NL → Code, Backtesting and Execution, all in one product
Many hand wiring tools	Nginx + Vue UI, Flask API, workers, exchange/LLM adapter
Opaque SaaS keys	Your infrastructure, exchange keys, large language model keys

Audience: Traders and quants, Python strategy writers, small teams building in-house or commercial trading products.

visual journey

▶ Watch product demos on YouTube Click on the preview card above to open the complete video walkthrough.
Integrated indicator development, charting, backtesting and fast trading	Artificial Intelligence Asset Analysis and Opportunity Radar
Trading robot workspace and automation templates	Strategic real-time operations, performance and monitoring

at a glance

• Research & Artificial Intelligence - Multiple large language model analysis, watchlists, analysis history; optional collection/calibration; NL→indicator/strategy; post-backtest AI prompts; Polymarket as a research workflow. Agent gateway + MCP for cursor/Claude code/codebook.
• Build — IndicatorStrategy (dataframe signals, chart overlays) and ScriptStrategy ( on_bar , explicit orders); professional chart UI.
• Validate - Server-side backtesting, indicators, equity curves, strategy snapshots.
• Operate – Cryptocurrency execution, fast trading, IBKR/MT5, notifications (Telegram, email, SMS, Discord, webhook).
• Platform - Docker Compose, Postgres, Redis, OAuth, multi-user mode, points/membership/USDT billing switching.

Architecture

Stack: Nginx serves the prebuilt Vue app ( frontend/dist ); Flask API runs policy/AI/billing services; PostgreSQL maintains state; Redis supports workers. Exchanges, brokers, large language models, and payments are all plugged in through environment-driven adapters. Cryptocurrency market data and command execution paths are separated by design. Length (short film): Data flow → Backtesting/Strategy Engine → Real-time runtime → Exchange adapter; pending orders, issued by venue.

System diagram

 flowchart LR U[Trader / Operator / Researcher] subgraph FE[Frontend Layer] WEB[Vue Web App] NG[Nginx Delivery] end subgraph BE[Application Layer] API[Flask API Gateway] AI[AI Analysis Services] STRAT[Strategy and Backtest Engine] EXEC[Execution and Quick Trade] BILL[Billing and Membership] end subgraph DATA[State Layer] PG[(PostgreSQL 16)] REDIS[(Redis 7)] FILES[Logs and Runtime Data] end subgraph EXT[External Integrations] LLM[LLM Providers] EXCH[Crypto Exchanges] BROKER[IBKR / MT5] MARKET[Market Data / News] PAY[TronGrid / USDT Payment] NOTIFY[Telegram / Email / SMS / Webhook] end U --> WEB WEB --> NG --> API API --> AI API --> STRAT API --> EXEC API --> BILL AI --> PG STRAT --> PG EXEC --> PG BILL --> PG API --> REDIS API --> FILES AI --> LLM AI --> MARKET EXEC --> EXCH EXEC --> BROKER BILL --> PAY API --> NOTIFY Installation and First Time Setup (Docker Compose) flowchart LR U[Trader / Operator / Researcher] subgraph FE[Frontend Layer] WEB[Vue Web App] NG[Nginx Delivery] end subgraph BE[Application Layer] API[Flask API Gateway] AI[AI Analysis Services] STRAT[Strategy and Backtest Engine] EXEC[Execution and Quick Trade] BILL[Billing and Membership] end subgraph DATA[State Layer] PG[(PostgreSQL 16)] REDIS[(Redis 7)] FILES[Logs and Runtime Data] end subgraph EXT[External Integrations] LLM[LLM Providers] EXCH[Crypto Exchanges] BROKER[IBKR / MT5] MARKET[Market Data / News] PAY[TronGrid / USDT Payment] NOTIFY[Telegram / Email / SMS / Webhook] end U --> WEB WEB --> NG --> API API --> AI API --> STRAT API --> EXEC API --> BILL AI --> PG STRAT --> PG EXEC --> PG BILL --> PG API --> REDIS API --> FILES AI --> LLM AI --> MARKET EXEC --> EXCH EXEC --> BROKER BILL --> PAY API --> NOTIFY

Fast path: Try again in two minutes first. The following steps are a complete checklist (with the same results and more details).

This section mirrors the typical "local deployment" path: Prepare host → Get code → Configure secrets → Start stack → Validate → Harden → Optionally wire AI . Node.js is not required: Warehouse shipping prebuilt UI under frontend/dist and Nginx serves it inside the frontend container.

Prerequisites

Item	Notes
Docker + Docker Compose v2	For Postgres, Redis, API and static UI.
git	Clone this repository.
port (default)	8888 (web), 5000 (API, bound to 127.0.0.1 ), 5432 / 6379 (DB/Redis, loopback by default). Change via root .env if they collide.
Disk	Post volume grows with users, policies, and logs; plan for at least a few GB for serious use.

1) Clone the repository

git clone https://github.com/brokermr810/QuantDinger.git cd QuantDinger 2) Create backend configuration (mandatory) git clone https://github.com/brokermr810/QuantDinger.git cd QuantDinger

 Almost all runtime behavior is driven by cp backend_api_python/env.example backend_api_python/.env

backend_api_python/.env (database URL, admin user, LLM keys, workers, billing switches, etc.). Optional repository root.env .env adjusts Compose-level concerns such as ports and mirroring ( IMAGE_PREFIX ).

3) Set SECRET_KEY before the first boot (mandatory)

The API refuses to start if SECRET_KEY is still the placeholder from env.example . This blocks accidental insecure deployments.

Linux / macOS (recommended):

 The script overwrites the ./scripts/generate-secret-key.sh

SECRET_KEY= line in backend_api_python/.env using Python's secrets module.

Manual (any OS): generate a long random string (for example 64 hex chars) and set SECRET_KEY=... in backend_api_python/.env .

4) Start stack

 Services: docker-compose up -d --build

postgres , redis , backend , frontend (see docker-compose.yml for healthchecks and port mappings).

5) Verify and log in

Check	URL/command
Web UI	http://localhost:8888 (override host/port with FRONTEND_HOST / FRONTEND_PORT in root .env if needed).
API Health	http://localhost:5000/api/health
Logs	docker-compose logs -f backend

Default administrator (change immediately for production environments):

• User : quantdinger
• Password : 123456 (from env.example ; override with ADMIN_USER / ADMIN_PASSWORD in .env before first use if you prefer).

There is also the setting FRONTEND_URL in backend_api_python/.env to the URL users actually use (including https:// behind a reverse proxy); it affects redirects, CORS-related settings, and some generated links.

6) Optional: Enable AI function

AI analysis, NL→code, and related flows need at least one LLM provider configured. Open backend_api_python/env.example , find the AI ​​/ LLM block, copy the relevant keys into your .env (for example LLM_PROVIDER + OPENROUTER_API_KEY , or another supported provider). Restart the backend after edits.

7) Windows comments

Use Docker desktop (WSL2 backend recommended). PowerShell in the repository root:

 git clone https://github.com/brokermr810/QuantDinger.git cd QuantDinger Copy-Item backend_api_python\env.example -Destination backend_api_python\.env $key = py -c "import secrets; print(secrets.token_hex(32))" (Get-Content backend_api_python\.env) -replace '^SECRET_KEY=.*$', "SECRET_KEY=$key" | Set-Content backend_api_python\.env -Encoding UTF8 docker-compose up -d --build If git clone https://github.com/brokermr810/QuantDinger.git cd QuantDinger Copy-Item backend_api_python\env.example -Destination backend_api_python\.env $key = py -c "import secrets; print(secrets.token_hex(32))" (Get-Content backend_api_python\.env) -replace '^SECRET_KEY=.*$', "SECRET_KEY=$key" | Set-Content backend_api_python\.env -Encoding UTF8 docker-compose up -d --build

py is not on PATH, use python or python3 in the one-liner that generates $key . Line endings should remain UTF-8; avoid editors that strip newlines from .env .

Troubleshooting (first startup)

Symptom	Things to note
The backend exits immediately	SECRET_KEY still default, or invalid .env syntax. Read docker-compose logs backend .
A blank page or API error appears in the browser	FRONTEND_URL / origins mismatch; API not reachable from the host you opened.
Port already in use	Another Postgres, Redis, or local service on 5432 / 6379 / 5000 / 8888 . Adjust variables in root .env per docker-compose.yml .
Many Field Strategies, "Refuse to Start"	Raise STRATEGY_MAX_THREADS in backend_api_python/.env and restart API (see comments in env.example ).

Common Docker commands

 docker-compose ps docker-compose logs -f backend docker-compose restart backend docker-compose up -d --build docker-compose down Optional root docker-compose ps docker-compose logs -f backend docker-compose restart backend docker-compose up -d --build docker-compose down

.env (Compose only)

For custom porting or mirror/prefix for base images (slow Docker Hub pulls), create a file named .env in the repository root (same directory as docker-compose.yml ):

 FRONTEND_PORT=3000 BACKEND_PORT=127.0.0.1:5001 IMAGE_PREFIX=docker.m.daocloud.io/library/ Production-style TLS, domain and reverse proxy placement covered in FRONTEND_PORT=3000 BACKEND_PORT=127.0.0.1:5001 IMAGE_PREFIX=docker.m.daocloud.io/library/

Cloud deployment .

Recommended first meeting (product guide)

After the stack is healthy: (1) Run AI asset/market analysis so the LLM and data paths are verified; (2) Open the indicator IDE , load a symbol, and run the signal backtest for a small time period; (3) Optionally draft the indicator first using AI code generation , then edit it in Python; (4) When ready, hook up to exchange API keys (profiles/credentials), use a test connection , and then explore the live strategy or quick trade you intend to use in execution mode. This sequence would reveal structural problems well in advance of actual capital.

Simple example: Python instruction strategy

This is the Python native strategy logic type designed by QuantDinger:

 # @param sma_short int 14 Short moving average # @param sma_long int 28 Long moving average sma_short_period = params.get('sma_short', 14) sma_long_period = params.get('sma_long', 28) my_indicator_name = "Dual Moving Average Strategy" my_indicator_description = f"SMA {sma_short_period}/{sma_long_period} crossover" df = df.copy() sma_short = df["close"].rolling(sma_short_period).mean() sma_long = df["close"].rolling(sma_long_period).mean() buy = (sma_short > sma_long) & (sma_short.shift(1) <= sma_long.shift(1)) sell = (sma_short < sma_long) & (sma_short.shift(1) >= sma_long.shift(1)) df["buy"] = buy.fillna(False).astype(bool) df["sell"] = sell.fillna(False).astype(bool) The complete example is as follows: # @param sma_short int 14 Short moving average # @param sma_long int 28 Long moving average sma_short_period = params.get('sma_short', 14) sma_long_period = params.get('sma_long', 28) my_indicator_name = "Dual Moving Average Strategy" my_indicator_description = f"SMA {sma_short_period}/{sma_long_period} crossover" df = df.copy() sma_short = df["close"].rolling(sma_short_period).mean() sma_long = df["close"].rolling(sma_long_period).mean() buy = (sma_short > sma_long) & (sma_short.shift(1) <= sma_long.shift(1)) sell = (sma_short < sma_long) & (sma_short.shift(1) >= sma_long.shift(1)) df["buy"] = buy.fillna(False).astype(bool) df["sell"] = sell.fillna(False).astype(bool)

• docs/examples/dual_ma_with_params.py
• docs/examples/multi_indicator_composite.py
• docs/examples/cross_sectional_momentum_rsi.py

Supported markets, brokers and exchanges

cryptocurrency exchange

Venue	Coverage
Binance	Spot, futures, margin
OKX	Spot options, perpetual options
Bitget	Spot, futures, copy trading
Bybit	spot, linear futures
Coinbase	Spot
Kraken	spot, futures
KuCoin	spot, futures
Gate.io	spot, futures
Deepcoin	derivative integral
HTX	Spot, USDT guaranteed perpetual stocks

traditional market

Market	Broker/Source	Execution
US stocks	IBKR, Yahoo Finance, Finnhub	Source: IBKR
Forex	MT5, OANDA	Via MT5
Futures	Exchange and data integration	Data and workflow support

prediction market

Polymarket currently operates as a research and analysis workflow rather than executing directly on the platform in real time. It is suitable for market inquiry, divergence analysis, opportunity scoring and AI-assisted review.

strategic development model

QuantDinger supports two main policy writing models:

IndicatorStrategy

• Python script based on data frame
• buy / sell signal generation
• Chart rendering and signal-based backtesting
• Best for research, indicator logic and visual strategy prototyping

ScriptStrategy

• event-driven on_init(ctx) / on_bar(ctx, bar) scripts
• explicit runtime control with ctx.buy() , ctx.sell() , ctx.close_position()
• Best for stateful strategies, execution-oriented logic, and real-time alignment

For the complete developer workflow, please see:

• Strategic Development Guide
• Cross-sectional strategy guide
• Strategy example

The example scripts live in docs/examples/ and are kept aligned with the current strategy development guides.

Repository layout

 QuantDinger/ ├── backend_api_python/ # Open backend source code │ ├── app/routes/ # REST endpoints │ ├── app/services/ # AI, trading, billing, backtest, integrations │ ├── migrations/init.sql # Database initialization │ ├── env.example # Main environment template │ └── Dockerfile ├── frontend/ # Prebuilt web UI (sources: QuantDinger-Vue; mobile app: QuantDinger-Mobile) │ ├── dist/ │ ├── Dockerfile │ └── nginx.conf ├── docs/ # Product, strategy, and deployment documentation ├── docker-compose.yml ├── LICENSE └── TRADEMARKS.md Configuration area QuantDinger/ ├── backend_api_python/ # Open backend source code │ ├── app/routes/ # REST endpoints │ ├── app/services/ # AI, trading, billing, backtest, integrations │ ├── migrations/init.sql # Database initialization │ ├── env.example # Main environment template │ └── Dockerfile ├── frontend/ # Prebuilt web UI (sources: QuantDinger-Vue; mobile app: QuantDinger-Mobile) │ ├── dist/ │ ├── Dockerfile │ └── nginx.conf ├── docs/ # Product, strategy, and deployment documentation ├── docker-compose.yml ├── LICENSE └── TRADEMARKS.md

Use backend_api_python/env.example as the primary template. Key areas include:

Area	Examples
Authentication	SECRET_KEY , ADMIN_USER , ADMIN_PASSWORD
Database	DATABASE_URL
LLM/AI	LLM_PROVIDER , OPENROUTER_API_KEY , OPENAI_API_KEY
OAuth	GOOGLE_CLIENT_ID , GITHUB_CLIENT_ID
Security	TURNSTILE_SITE_KEY , ENABLE_REGISTRATION
Billing	BILLING_ENABLED , BILLING_COST_AI_ANALYSIS
Membership	MEMBERSHIP_MONTHLY_PRICE_USD , MEMBERSHIP_MONTHLY_CREDITS
USDT payment	USDT_PAY_ENABLED , USDT_TRC20_XPUB , TRONGRID_API_KEY
Optional data API	TWELVE_DATA_API_KEY , FINNHUB_API_KEY , TIINGO_API_KEY , ADANOS_API_KEY
Proxy	PROXY_URL
Workers	ENABLE_PENDING_ORDER_WORKER , ENABLE_PORTFOLIO_MONITOR , ENABLE_REFLECTION_WORKER
AI tuning	ENABLE_AI_ENSEMBLE , ENABLE_CONFIDENCE_CALIBRATION , AI_ENSEMBLE_MODELS

Documentation

Doc	Notes
Changelog	Release and migration
README (Chinese)	China Overview
JA · KO · TH · VI · AR	Concise localized README (Japanese, Korean, Thai, Vietnamese, Arabic)
Cloud deployment	HTTPS, reverse proxy, production
Multi-user	Postgres multi-tenant model
Agent Environment · Artificial Intelligence Integration · Quickstart · OpenAPI · MCP Server	Coding agents & MCP ( quantdinger-mcp on PyPI)

Strategy: EN · CN · TW · JA · KO · Cross Section EN / CN · ExamplesIntegrations with Alerts: IBKR · MT5 EN / CN · OOOS EN / CN ·Telegram/Email/SMS Configurationdocs docs/ ( NOTIFICATION * ).

FAQ

Is QuantDinger really self-made?

Yes. The default deployment model is your own Docker Compose stack with your own database, Redis instance, credentials, and environment configuration.

Is QuantDinger only for cryptocurrency trading?

No. Cryptocurrencies are the main focus, but the platform also includes IBKR workflows for US equities, MT5 workflows for FX, and Polymarket research support.

Can I write the strategy directly in Python?

Yes. QuantDinger supports both dataframe-style IndicatorStrategy development and event-driven ScriptStrategy development. You can also use AI to generate a starting point and then edit it yourself.

Is this a research tool or a live trading platform?

It’s both. QuantDinger is designed to bring together artificial intelligence research, charting, strategy development, backtesting, fast trading processes and real-time execution into one system.

Can I use QuantDinger commercially?

The backend uses Apache 2.0 authorization. The web front-end source code ( QuantDinger-Vue ) is available under a separate source code license - please review both and contact the project for a commercial front-end license if necessary. This mobile application repository is open source under its own license (see the repository for details).

Is there a mobile app?

Yes—see QuantDinger-Mobile (open source) which connects to your own backend or SaaS.

Exchange partner links

The following link can be found within the app Profile -> Open Account and subject to venue policies, users may be eligible for transaction fee rebates.

Exchange	Registration link
Binance	Register
Bitget	Register
Bybit	Register
OKX	Register
Gate.io	Register
HTX	Register

License and Business Terms

• The backend source code is licensed under the Apache License 2.0 . See LICENSE .
• This repository distributes the front-end interface as pre-built files for comprehensive deployment.
• The front-end source code is available separately from QuantDinger. The front-end is available under the QuantDinger Front-End Source Code License v1.0 .
• Under this front-end license, use is free for non-commercial and qualified nonprofit use, while commercial use requires a separate commercial license from the copyright holder.
• Trademark, branding, attribution, and watermark usage are governed separately and may not be removed or altered without permission. See TRADEMARKS.md .

For commercial licensing, front-end source code access, brand licensing or deployment support:

• Website: quantdinger.com
• Telegram: t.me/worldinbroker
• Email: support@quantdinger.com

Legal Notices and Compliance

QuantDinger is intended to be lawful only for research, education and compliance transactions - not involving fraud, market manipulation, sanctions circumvention, money laundering or other illegal activities. Operators must comply with applicable laws, licensing and exchange rules in the jurisdictions in which they are deployed. This project does not provide legal, tax, investment or regulatory advice. Use of the software is at your own risk; to the extent permitted by law, contributors are not responsible for trading losses, service interruptions, or regulatory enforcement resulting from use or misuse.

Community & Support

• Contribution Guide
• Contributors
• Report a bug/Request a feature
• Email: support@quantdinger.com

Support projects

Cryptocurrency Donations:

 star history 0x96fa4962181bea077f8c7240efe46afbe73641a7

Acknowledgments

QuantDinger is built on a strong open source ecosystem. Special thanks to the following projects:

• Flask
• Pandas
• CCXT
• yfinance
• Vue.js
• Ant Design Vue
• KLineCharts
• ECharts
• Capacitor
• bip-utils

_{If QuantDinger is useful to you, GitHub stars can be a great help for projects.}

---

Article source: https://github.com/brokermr810/QuantDinger