QuantDinger AI Trading OS
Turn AI-assisted market research into Python strategies, backtests, paper trading, live execution, and monitoring.
Least privilege, user confirmation, data-flow transparency, sensitive-data handling, and external-effect controls have strong static support: ports bind to loopback by default; production containers are described as non-root, read-only, and capability-dropped; agent tokens are scoped, rate-limited, hashed, and audited; and agent trading defaults to paper mode. Live agent trading requires token scope, paper_only=false, a server switch, and operator limits and allowlists. The README explicitly warns that real orders can be submitted and maps flows among clients, APIs, databases, Redis, workers, and broker adapters. Credentials and MFA secrets are encrypted, environment files use mode 600, and operators are warned against public infrastructure exposure and example passwords. Dependency security receives 2 because CI shows lock validation, constrained tool versions, image SBOMs, and provenance, but the supplied material contains neither vulnerability-scanning configuration/results nor the dependency manifests themselves. Rollback receives 2 because PostgreSQL and durable-Redis backups, durable commands, and reconciliation are mentioned, but live-order reversal, deployment rollback, and disaster-recovery procedures are not shown. Source attribution receives 2: the README identifies Open Byte Inc., support contacts, and public channels, while the license appendix mentions quantdinger.com; however, publisher identity is unverified and the evidence lacks a definitive copyright-owner declaration or contributor governance.
The architecture, execution flows, version conventions, and CI configuration are internally consistent. CI statically demonstrates syntax checks, linting, migrations, sharded tests, release gates, Compose validation, version-drift checks, and encoding checks, supporting full self-consistency credit. Dependency availability receives 2: Python 3.12, PostgreSQL 18, Redis 8, lock-file installation, prebuilt images, and multi-architecture publishing are documented, but major capabilities depend on external AI providers, exchanges, and brokers, with no supplied offline fallback or availability matrix. Failure messages receive 2 because configuration checks, health endpoints, observability, alerts, and an explicit CI error for empty test shards are shown, while concrete user-facing runtime error examples, an error taxonomy, and detailed recovery behavior are absent.
The audience and scenarios clearly cover independent traders, Python strategy authors, and small teams across research, backtesting, paper trading, live execution, and monitoring. Capability boundaries distinguish HTTP handling, long-running trading loops, finite Celery work, schedulers, and third-party responsibilities, while explicitly disclaiming investment advice. Trigger precision is strong because live agent trading has four independent gates and work is deliberately routed among durable commands, finite jobs, and long-lived runtimes. Environment fit earns full credit for prebuilt and source installations, Linux/macOS/Windows instructions, Docker Compose, local and production overlays, optional monitoring, resource-constrained deployment guidance, rootless/NFS notes, and multi-architecture images.
Information architecture is unusually concrete, with repository layout, execution-path mappings, and a table identifying where each category of change belongs. Installation notes cover quick and source installs, mandatory secrets, administrator migration behavior, production validation, and troubleshooting references. Naming and version stability are supported by VERSION, semantic release tags, Strategy API V2, /api/agent/v1, consistency checks, and an API compatibility workflow. Examples and FAQ receive 2: many commands and guide links are provided, but the supplied material does not contain a full FAQ or an end-to-end agent-call example. Known limitations earn full credit because the sources state live-trading risk, jurisdictional responsibility, third-party exclusions, main-only security support, separately hosted frontend source, and optional monitoring. The complete Apache-2.0 license matches the metadata. Versioning and changelog practices are supported by tags, generated release notes, and version checks. Maintenance responsibility receives 2 because product attribution, a support address, security response targets, and a main-only support policy exist, but publisher identity remains unknown and no maintainer roster, governance model, or long-term support commitment is shown.
Outputs appear directly usable: inspectable strategy code, backtests, experiments, reports, execution state, audit logs, metrics, dashboards, and alerts are exposed through web, mobile, API, Agent Gateway, and MCP surfaces. Marginal value earns full credit because the repository integrates AI research, strategy development, backtesting, paper/live execution, and monitoring into one self-hosted workflow while preserving operator control and a shared service layer. Cost-benefit receives 2: the core stack can remain smaller and observability is optional, while prebuilt images reduce setup effort; however, PostgreSQL, two Redis instances, several workers, and optional Prometheus/Grafana/Alertmanager create substantial operational overhead, and no resource benchmarks, cost estimates, or measured performance benefits are supplied.
Major claims are mapped to named directories, configurations, documents, OpenAPI artifacts, tests, and CI steps; execution and change-location tables make the claimed design especially traceable. Cross-source corroboration receives 2 because SECURITY.md and the workflows support some README claims about security, versions, and checks, but the supplied evidence excludes the core trading, authorization, and encryption implementations and contains no independent or executed results. Fact/inference separation is strong: defaults, production recommendations, external responsibilities, and disclaimers are distinguished clearly, and this assessment does not treat configured CI as proof that a run succeeded.
- The system can submit real orders; begin with paper trading and isolate live access with restricted API keys, the server-side live switch, limits, and allowlists.
- Manual Docker deployments may retain the quantdinger/123456 compatibility credential; any network-accessible deployment must change it before first start or immediately after first login.
- This review covers only the supplied static files. Tests were not executed, and trading, authorization, encryption, and order-reconciliation implementations were not inspected; configured CI is not proof of a successful run.
- Only the main branch is declared supported for security updates, so a deployment pinned to this historical revision may miss later fixes.
- Production operators remain responsible for backups, TLS, network isolation, third-party availability, regulatory compliance, and recovery from live-order incidents.
What does this agent do, and when should you use it?
QuantDinger is an open-source, self-hosted AI Trading OS for independent traders, Python strategy authors, and small teams. It combines AI-assisted research, indicators and Strategy API V2 development, server-side backtesting, paper or live execution, and monitoring across crypto, stock, and forex workflows. A Flask and Gunicorn API delegates long-running strategy ownership to trading-worker, scheduling to scheduler-worker, and finite retryable jobs to Celery over a dedicated Redis instance, while PostgreSQL stores durable state and audit records. Users can work through desktop web, mobile H5, the Human API, Agent Gateway, or a standalone MCP server documented for clients including Codex, Claude Code, and Cursor. This is not a managed black-box signal service: strategy code, market data, credentials, risk settings, deployment, and the resulting operational and compliance burden remain under the operator's control.
The documented pipeline is “AI research → Strategy code → Backtest → Paper/Live execution → Monitoring.” QuantDinger can conduct research through multiple AI providers and custom endpoints, consume market, macro, news, and sentiment data, and run Python indicators and Strategy API V2 code. Synchronous requests pass from app/routes to app/services and then to PostgreSQL, Redis cache, data providers, or trading adapters; durable strategy commands are written to PostgreSQL and consumed by trading-worker, which owns leases, strategy runtimes, pending orders, broker sessions, and reconciliation. Finite jobs travel through Redis jobs to app/tasks in celery-worker, while scheduler-worker performs portfolio, deployment, payment, and signal schedules. Its trading surfaces include Binance, OKX, Bitget, Bybit, Gate, HTX, IBKR, and Alpaca workflows, producing backtest and experiment results, reports, orders, runtime state, and audit records. Optional Prometheus, Grafana, and Alertmanager services collect metrics, expose dashboards, and route alerts. MCP clients call approved tools through mcp_server and /api/agent/v1 without receiving broker credentials or administrator JWTs.
- An independent trader wants to turn an idea into a Python strategy and move through backtesting, paper validation, and controlled live deployment on infrastructure they own.
- A small quant team needs durable PostgreSQL state and audit trails while separating HTTP traffic, long-lived strategy runtimes, scheduled work, and finite asynchronous jobs.
- A crypto trader wants one strategy environment spanning adapters for Binance, OKX, Bitget, Bybit, Gate, or HTX.
- A stock or traditional-market developer wants Alpaca or IBKR workflows while retaining local control of strategy code, broker credentials, and risk settings.
- A Codex, Claude Code, or Cursor user wants to invoke authorized research and trading operations over MCP without exposing administrator JWTs or broker secrets to the client.
- An operations-focused team needs optional Prometheus, Grafana, and Alertmanager coverage for the API, workers, PostgreSQL, and Redis.
What are this agent's strengths and limitations?
- Research, Python strategy authoring, backtesting, paper trading, live execution, and monitoring form one documented workflow instead of requiring manual handoffs among separate tools.
- The process model explicitly separates the HTTP API, trading-worker, scheduler-worker, celery-worker, celery-beat, and migrations, including a distinction between long-lived runtimes and finite retryable work.
- The integration surface spans several crypto venues plus IBKR and Alpaca, while AI options include OpenRouter, OpenAI-compatible APIs, Google, DeepSeek, Grok, MiniMax, and custom endpoints.
- Agent tokens are hashed, scoped, rate-limited, and audited; agent trading is paper-only by default and live access requires both token-level and server-side authorization.
- Deployment choices include prebuilt images, one-command installers, a source Compose stack, a production-hardening overlay, and an optional observability overlay.
- Self-hosting leaves the operator responsible for PostgreSQL, two purpose-separated Redis instances, secrets, backups, migrations, TLS, worker health, and monitoring.
- Live mode can submit real orders and lose capital; backtests, simulations, indicators, and AI output do not establish future performance, and jurisdictional compliance remains the user's responsibility.
- Production setup requires several independent secrets and passwords; incorrect ownership, read-only mounts, or retained example credentials can prevent configuration changes or create security exposure.
- Desktop and mobile client source lives in separate repositories under their own source-available licenses; Apache-2.0 covers the backend code but does not grant trademark rights.
- Exchange, broker, AI-provider, and data-source functions depend on external networks and third-party services whose availability, permissions, pricing, and failure behavior are outside this repository.
How do you install or deploy this agent?
The shortest path requires Docker with Compose v2; local Node.js and Python installations are not required. On Linux or macOS run:
curl -fsSL https://raw.githubusercontent.com/OpenByteInc/QuantDinger/main/install.sh | bashOn Windows PowerShell run:
irm https://raw.githubusercontent.com/OpenByteInc/QuantDinger/main/install.ps1 | iexThe installer requests initial administrator credentials, generates required secrets, downloads the GHCR Compose stack, and starts it. Open http://127.0.0.1:8888 for the web client, http://127.0.0.1:8889 for mobile H5, or http://127.0.0.1:5000/api/health for the API health endpoint.
For a source deployment run:
git clone https://github.com/OpenByteInc/QuantDinger.git
cd QuantDinger
cp backend_api_python/env.example backend_api_python/.env
cp .env.example .envSet SECRET_KEY, CREDENTIAL_ENCRYPTION_KEY, ADMIN_USER, and ADMIN_PASSWORD in backend_api_python/.env. Set POSTGRES_PASSWORD, REDIS_PASSWORD, CELERY_REDIS_PASSWORD, and GRAFANA_ADMIN_PASSWORD in the root .env. Generate independent values with python -c "import secrets; print(secrets.token_hex(32))", then run docker compose up -d --build followed by docker compose ps. Manual Docker deployments retain quantdinger / 123456 only for backward compatibility when administrator variables remain at their defaults; that credential is unsuitable for an internet-facing deployment, and the one-command installer refuses 123456 as the selected password.
How do you use this agent?
Sign in at http://127.0.0.1:8888 and configure the required AI provider, market-data source, and broker or exchange credentials. Develop Python indicators and Strategy API V2 strategies, run server-side backtests, inspect experiment output, and begin with paper trading using restricted API keys. Enable live execution only after reviewing strategy behavior, order limits, allowlists, and applicable jurisdictional requirements. Agent and MCP access is exposed under /api/agent/v1; agent-driven live trading requires a token with trading scope, paper_only=false on that token, AGENT_LIVE_TRADING_ENABLED=true on the server, and operator-configured limits and allowlists. Before production deployment, validate secrets with python backend_api_python/scripts/check_production_config.py --env-file .env --env-file backend_api_python/.env. The hardened runtime with optional monitoring can then be started with docker compose -f docker-compose.yml -f docker-compose.production.yml -f docker-compose.observability.yml up -d --build.
How does this agent compare with similar options?
Unlike a black-box signal service, QuantDinger keeps strategy code, risk settings, credentials, and deployment under the operator's control. Unlike a design tied to one model vendor, it documents OpenRouter, OpenAI-compatible APIs, Google, DeepSeek, Grok, MiniMax, and custom endpoints, although each still requires its own configuration and service access. The base Compose stack also differs from an always-on monitoring bundle: Prometheus, Grafana, and Alertmanager are optional through the observability overlay.