DEV Community: yuhang chen

[Open Source] A super powerful AI-Agent quantitative trading tool: QuantDinger

yuhang chen — Sun, 25 Jan 2026 18:43:24 +0000

The AI quantitative trading platform, developed over six months, has been officially open-sourced under the Apache 2.0 license, making it commercially usable.
The platform supports all major markets: US stocks, A-shares, Hong Kong stocks, cryptocurrencies, forex, and futures.
It's a viable alternative to TradingView, capable of AI-driven strategy development and indicator plotting on candlestick charts. It also supports a multi-user version and one-click deployment via local Docker.
Demo address: https://ai.quantdinger.com
GitHub address: https://github.com/brokermr810/QuantDinger
If you find it useful, please give us a star! Your support is our motivation for improvement. We are also recruiting like-minded project administrators to manage the repository and build an open-source community together!

QuantDinger: Build, Backtest, and Trade with AI – An Open-Source, Local-First Quant Platform in Python

yuhang chen — Sat, 24 Jan 2026 18:12:13 +0000

Feeling good today ~
QuantDinger just hit another small milestone: Officially partnered with the Indiana University Quantitative Finance Society (QFS)! Grateful for their support — together pushing quant finance education and nurturing the next gen of quants

Added global financial market monitoring to the dashboard — now you can scan crypto, US/HK stocks, forex, commodities in one view. No more FOMO

From 0 to 441 stars + 119 forks now, every commit feels like it's paying off thanks to the community.
As a solo dev + growing open-source spark, reaching this point is genuinely exciting.
In the AI era, local-first, privacy-focused, Python-native quant tooling still feels unbeatable Keep grinding! Next goal: get more people using it — strategy contributions, translations, bug fixes, docs all super welcome ~
What quant / AI trading side project are you working on lately? Drop it in the comments, let's vibe GitHub: https://github.com/brokermr810/QuantDinger
Feedback/Collab: brokermr810@gmail.com or Telegram#QuantDinger #QuantFinance #AITrading #OpenSource #Python

I Built an AI-Powered Quant Trading Platform That Runs 100% Locally – Introducing QuantDinger

yuhang chen — Sat, 24 Jan 2026 18:07:12 +0000

Hey dev.to community

If you've ever tried building algorithmic trading strategies, you probably know the pain:Backtesting tools are either too basic (no real AI help) or locked in proprietary platforms
Data privacy is a constant worry when using cloud-based services
Switching between crypto exchanges, stocks, forex brokers feels like juggling different APIs
Strategy development in Pine Script or limited DSLs is frustrating if you're a Python person

After years of frustration with fragmented tools, I decided to build something better: QuantDinger — a fully open-source, local-first quantitative trading platform powered by AI.It's designed for quants, algo traders, and Python developers who want full control, privacy, and modern AI assistance — without sending your strategies or data to any vendor.What is QuantDinger?QuantDinger is a complete end-to-end quant workflow in one Python-native app:AI-assisted strategy creation → Use LLMs (OpenAI, Grok, Gemini, DeepSeek, local models via Ollama) as co-pilot to generate, debug, and optimize Python strategies
High-performance backtesting → Vectorized + multi-threaded engine, supports parameter optimization, walk-forward analysis
Live trading execution → Unified interface for crypto (10+ exchanges via CCXT), US/HK stocks (Interactive Brokers), forex (MT5 bridge)
Multi-agent research system → LLM agents with reflection loops, local RAG for market sentiment, news, fundamentals
Beautiful dashboard → Real-time charts (Plotly), portfolio tracking, global market overview, multi-language UI (English/中文/日本語/한국어)

Everything runs locally or on your own server. Your API keys, historical data, and trading logic never leave your machine.Why Local-First + Privacy Matters in 2025With increasing regulations (GDPR, data sovereignty laws) and rising AI privacy concerns, many traders are moving away from cloud-only platforms. QuantDinger gives you:Zero vendor lock-in
No telemetry or forced updates
Full auditability of every line of code (Apache 2.0 license)

Key Technical HighlightsBackend: FastAPI + SQLModel + Celery for async tasks
Frontend: React + Vite + Tailwind + shadcn/ui (responsive, mobile-friendly)
AI Layer: LangChain + local RAG + multi-LLM support
Data Handling: DuckDB for fast local storage, Parquet for historical data
Deployment: One-command Docker Compose (backend + frontend + Redis + Postgres optional)

Quick Start in 3 StepsClone the repo:bash

git clone https://github.com/brokermr810/QuantDinger.git
cd QuantDinger

Start with Docker (recommended):bash

docker compose up -d

Open http://localhost:5173 → Create account → Connect your exchange/broker → Start building!

Or run without Docker (needs Python 3.11+, Node 18+):bash

Backend

poetry install
poetry run python main.py

Frontend (separate terminal)

cd frontend
pnpm install
pnpm dev

Demo & ScreenshotsHere's a quick intro video (3 mins): https://youtu.be/HPTVpqL7knM

Live hosted demo (for quick try, but local is recommended): https://ai.quantdinger.com
Recent updates: Added DeepSeek LLM support, fixed IBKR position sync, improved mobile UI

Next up: More built-in strategies, reinforcement learning agents, better optimization UI, community strategy marketplace.I Need Your Help!This is a solo + community project, and I'd love your input:Try it out and share your experience (good/bad)
What quant pain points does this solve (or miss)?
Contribute code, docs, translations, or strategy examples
Star/fork on GitHub if it looks interesting

Drop a comment below — tell me what kind of trading setup you use, or what feature you'd kill for in a tool like this.Thanks for reading, and happy (profitable) coding! #opensource #python #quant #trading #algotrading #ai #fintech #backtesting

QuantDinger: An open-source local quantitative trading platform.

yuhang chen — Thu, 08 Jan 2026 09:57:58 +0000

Project Background and Functionality Project Positioning:

QuantDinger aims to create a "Local-First" open-source AI quantitative trading workbench. Designed as a self-hosted alternative to TradingView and QuantConnect, its core principle is to return data ownership to the user. Addressing the pain points of expensive SaaS platforms, it provides a self-hosted solution that integrates data acquisition, AI-driven investment research, strategy backtesting, and live trading.
Core Functional Entities:

Multi-source Data Aggregation: Unified data interfaces for cryptocurrencies (CCXT), US stocks (YFinance/Finnhub), and Chinese A-shares (AkShare) are provided, offering a standardized OHLCV (Open, High, Low, Close, Volume) data format.

Strategy development environment: Features a built-in code editor based on Monaco Editor, supporting strategy development using the Python language.

Visualization Charts: Integrates TradingView's Lightweight Charts library for candlestick chart display and technical indicator analysis.

LLM-assisted tools: Utilize external large language models (via OpenRouter API calls) to assist in generating code snippets or interpreting market news (existing as a functional module, not a core part of the system).

Live/Simulated Trading: Supports connecting to exchange APIs for order routing and asset management.

Technology Selection and Architecture Diagram Codebase directory structure (inferred based on common Flask/Vue projects):

codeText

downloadcontent_copy

expand_less

QuantDinger/
├── backend_api_python/        
│   ├── app/
│   │   ├── routes/             
│   │   ├── services/           
│   │   ├── models/             
│   │   └── utils/              
│   ├── quantdinger.db          
│   ├── requirements.txt        
│   └── run.py                  
├── quantdinger_vue/            
│   ├── src/                    
│   └── package.json            
└── docker-compose.yml

Technology Stack Details:

Frontend: Vue.js 3, Vite, TypeScript, Lightweight Charts (candlestick charts), Element Plus (UI components).

Backend: Python Flask (web framework), SQLAlchemy (ORM), Pydantic (data validation).

Data Adaptation Layer:

ccxt: Handles REST/WebSocket data from 100+ cryptocurrency exchanges.

akshare: Scrapes A-share financial data.

yfinance: Retrieves historical data for US stocks.

Persistence: SQLite (lightweight file-based database, no need for separate MySQL/PostgreSQL deployment).

Technology Stack Details:

Frontend: Vue.js 3, Vite, TypeScript, Lightweight Charts (candlestick charts), Element Plus (UI components).

Database Design The project uses SQLite (quantdinger.db) to store metadata, avoiding heavy database maintenance. The main data table (Model) design is as follows:

users table

Used for basic authentication.

Fields: id, username, password_hash, api_token.

api_keys table

Stores exchange access credentials.

Fields: id, exchange_name, api_key (AES encrypted storage), secret_key (AES encrypted storage), user_id.

strategies table

Stores user-written strategy code and configuration.

Fields: id, name, code_content (Text type, stores Python source code), timeframe (e.g., '1h', '1d'), symbol (e.g., 'BTC/USDT'), status (RUNNING/STOPPED).

logs / trade_history table

Records signals and transaction history during strategy execution.

Fields: id, strategy_id, timestamp, action (BUY/SELL), price, amount, message.

Detailed Implementation of Core Modules 4.1 Backend Interface Layer (app/routes) Based on Flask Blueprint, it implements RESTful APIs, mainly including:

Market Route (/api/market): Receives time range and symbol parameters from the frontend, calls the data service layer, and returns a JSON formatted candlestick chart array.

Strategy Route (/api/strategy):

POST /save: Receives a Python code string and stores it in the database.

POST /run: Triggers the strategy execution logic.

GET /logs: Polls to read strategy execution logs.

LLM Route (/api/llm): As a pass-through proxy, it encapsulates the frontend's Prompt and forwards it to the OpenRouter API, and then returns the returned Code or Text to the frontend. 4.2 Data Adaptation Service (app/services/data_factory.py)
This is a typical factory pattern implementation used to abstract away the differences between different data sources:

Defines a unified interface IDataSource, including the method fetch_ohlcv(symbol, timeframe, limit).

Crypto implementation class: Instantiates ccxt.binance() or ccxt.okx(), handling API signatures and network requests.

Stock implementation class: Calls functions from akshare or yfinance.download(), and converts the returned Pandas DataFrame into a unified [timestamp, open, high, low, close, volume] list format.

4.3 Strategy Execution Engine (app/services/execution_engine.py)
This is the core of the system, responsible for running the user's Python code.

Dynamic execution: Uses Python's built-in exec() function or importlib to dynamically load the user-written code string.

Sandbox/Context injection: When executing exec(), system-encapsulated API objects (such as buy(), sell(), get_data()) are injected through the locals parameter, allowing user code to directly call these functions without worrying about the underlying implementation.

Process management: To prevent strategy deadlocks from blocking the web service, each running strategy is usually started in a separate process or thread using multiprocessing.

Deployment and Running Steps The project's dependencies are quite complex (involving Python data science libraries and a Node environment), so using Docker is strongly recommended.

Environment configuration:

Create a .env file in the project root directory.

Configure key variables:

codeIni
downloadcontent_copy

expand_less

FLASK_APP=run.py
FLASK_ENV=production
SECRET_KEY=your_secure_key
OPENROUTER_API_KEY=sk-xxx

2.Building and Starting:

codeBash
downloadcontent_copy

expand_less

docker-compose up -d --build

Backend Container: Based on python:3.10-slim, automatically installs dependencies via pip and starts Flask (Gunicorn).

Frontend Container: Based on Nginx, builds Vue artifacts and hosts static files, while configuring a reverse proxy to forward /api requests to the Backend container.

Access:

Access via browser at http://localhost:80 (or the port mapped in docker-compose).

Initialize the administrator account (you may need to check docker logs for the initial password or create it manually on first startup).

Project Summary and Optimization Directions Project Summary: QuantDinger is essentially a web-based Python quantitative trading script runner. It lowers the barrier to using ccxt and pandas through a web interface and uses SQLite for lightweight data persistence. Its decentralized architecture ensures that trading strategies and API keys remain entirely under the user's control, making it suitable for privacy-sensitive individual traders with some Python experience.

Optimization Directions (Code and Architecture Level):

Security Enhancement (Sandboxing): Currently, using exec() to execute user code poses security risks. It is recommended to introduce Docker-in-Docker (DinD) or use gVisor to allocate independent sandbox containers for each strategy to prevent malicious code from accessing the file system.

Data Storage Upgrade: SQLite is not suitable for storing massive amounts of tick-level financial data. It is recommended to introduce TimescaleDB or InfluxDB to replace SQLite as the backend for market data storage to improve query efficiency.

Event-Driven Engine: The current architecture is biased towards simple script polling. It is recommended to refactor to an event-driven architecture, introducing a message queue (Redis/RabbitMQ) to achieve a low-latency link of "market data update -> trigger event -> strategy response -> trade execution".

Code Reusability and Modularization: Allow users to upload custom Python libraries or modules (.py files), not just single-file scripts, to reuse complex indicator calculation logic.

https://github.com/brokermr810/QuantDinger?tab=readme-ov-file