# UFund-Me/Qbot: a local AI quantitative research platform for Python 3.8 and 3.9

> Qbot bundles data collection, factor mining, backtesting and simulated trading into one local GUI application. It is a research workbench for retail quants, not a ready-made money machine, and the install path is narrow.

**UFund-Me/Qbot** — [🔥updating ...] AI 自动量化交易机器人(完全本地部署) AI-powered Quantitative Investment Research Platform. 📃 online docs: https://ufund-me.github.io/Qbot   ✨ :news: qbot-mini: https://github.com/Charmve/iQuant

- Repository: https://github.com/UFund-Me/Qbot
- Website: https://github.com/Charmve
- Stars: 18,514 · Forks: 2,598
- Language: Jupyter Notebook
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/ufund-me-qbot

## What Qbot is trying to fix for retail quantitative research

Most retail quant work happens in disconnected pieces: a script that pulls prices, a notebook that computes factors, a backtest library, and a separate broker terminal. Qbot's README describes the project as an AI-oriented automated quantitative investment platform that closes the loop from data acquisition through strategy development, backtesting, simulated trading and finally live trading. The stated audience is the retail trader who has a little Python and a little trading experience. The repository layout supports that claim: pyfunds/, pyfutures/ and pytrader/ sit alongside qbot/ and web/, with a main.py entry point and a GUI front end mentioned in the quick start.

The pitch is a single local application rather than a hosted service. The README makes a point of full local deployment, and the install instructions keep everything in a cloned directory under $HOME. That matters for anyone who does not want account credentials or strategy code leaving their machine. It also means you own the data pipeline, the storage and the failure modes.

## The layered architecture: data, strategy and trading engine

The README's own diagram is the clearest description of the design. It reads as Qbot = trading strategy + backtest system + automated quantitative trading + visualization, with each branch mapped to a component: quantstats for the dashboard, vnpy, pytrader and pyfunds for execution and fund handling, backtrader and easyquant for backtesting, and qlib plus deep learning strategies for the AI side.

That is a modular layered design with a data layer, a strategy layer and an abstracted trading engine. The README states that data and strategies have an intermediate representation so that multiple data interfaces and trading interfaces can be plugged in, and that user-defined strategies and factor mining are supported across stocks, funds, futures and crypto. The top-level directories mirror this: pyfunds/ and pyfutures/ for instrument-specific logic, pytrader/ for order handling, qbot/ for the core, and utils/ and scripts/ for shared code. The AI claim rests on the requirements file, which pulls in scikit-learn, tensorboard, tensortrade and pykalman, so the machine learning path is real rather than aspirational. The trade-off is that a layered abstraction over four asset classes and several execution backends is a lot of surface area for one project to keep coherent.

## Installing Qbot and running the GUI for the first time

The README gives a short quick start and points to docs/Install_guide.md for the full version. It states that Qbot has only been tested under Python 3.8 and Python 3.9, and that other versions are untested. Treat that as a hard constraint, not a suggestion.

Clone the repository into your home directory with a shallow clone, which is what the README shows:

```bash
cd ~ # $HOME as workspace
git clone https://github.com/UFund-Me/Qbot --depth 1

cd Qbot
```

Install the Python dependencies from the requirements file in the dev/ directory. Note that this is dev/requirements.txt, not the requirements.txt at the repository root:

```bash
pip install -r dev/requirements.txt
```

Two dependencies are commented out in the root requirements file and shipped as local wheels instead: wxPython and ta-lib. The comments point at dev/wxPython-4.2.0-cp38-cp38-linux_x86_64.whl and dev/TA_Lib-0.4.28-cp38-cp38-linux_x86_64.whl. Those filenames encode cp38 and linux_x86_64, so they only fit a Python 3.8 Linux environment.

Set PYTHONPATH to include the repository root and the multi-factor learner directory, then start the application:

```bash
export PYTHONPATH=${PYTHONPATH}:$(pwd):$(pwd)/backend/multi-fact/mfm_learner
python main.py  #if run on Mac, please use 'pythonw main.py'
```

The README notes that on macOS you should use pythonw main.py rather than python main.py. What you should see is the GUI described in the quick start: a front end for data, strategy selection, backtesting and simulated trading, backed by the local Python process. If the window does not appear on macOS, the pythonw detail is the first thing to check.

## Where Qbot breaks down, and when it is the wrong tool

The Python version pin is the first real limitation. The README says testing happened on 3.8 and 3.9 only. The bundled wxPython and ta-lib wheels are built for cp38 on Linux x86_64, so a modern Python on ARM macOS or Windows has no documented path in the quick start. The root requirements.txt also pins matplotlib==3.2.2 and pyglet==1.5.0, both old releases, which increases the chance of a resolver conflict when you install into an existing environment.

The second limitation is scope inflation. The README claims a full loop from data to live trading across stocks, funds, futures and crypto, with machine learning, reinforcement learning and multi-factor models. Each of those is a project in its own right. A repository that carries pyfunds/, pyfutures/, pytrader/, qbot/, web/ and backend/multi-fact/ at the top level is asking a lot of a small maintenance effort. The last push was on 2026-03-11, and the newest release listed is qbot-pro_v1.2.1 from 2024-06-16, with v1.0.1 and v1.0.0 before that in 2023. That gap between commits and tagged releases is worth noticing before you build a workflow on a specific version.

Third, the README is explicit that this is a research platform with backtesting and simulated trading before live access. It does not document rollback, order reconciliation or what happens when a live order is rejected. If your requirement is unattended execution with a documented recovery path, Qbot is the wrong layer to depend on.

## How Qbot differs from a plain backtrader or qlib setup

The obvious alternative is to assemble the pieces yourself: backtrader for event-driven backtests, qlib for the machine learning pipeline, and a broker library for execution. That approach gives you exact control over versions and no GUI to fight. Qbot's difference is that it wires those libraries together behind a local interface and adds fund and futures handling plus a visualization dashboard through quantstats. If you want a single application to click through strategies and factor results, that integration is the value. If you want a minimal, auditable pipeline, the integration is overhead.

A second comparison is with hosted quantitative platforms, which handle data storage and compute for you. Qbot's README frames local deployment as the point, so the difference is data locality and the absence of a service dependency, paid for with your own machine's setup and maintenance. The repository also references a smaller companion project, qbot-mini at github.com/Charmve/iQuant, which the README links but does not describe in detail.

## Licence and the cost of keeping Qbot running

Qbot is released under the MIT licence. That is permissive: you can use, modify and redistribute the code, including in commercial settings, provided the copyright notice and permission notice are retained. The repository's dependencies are separate works with their own licences, and several of them matter for a trading stack: backtrader, quantstats, akshare, efinance, yfinance and binance-connector all ship under their own terms. Check those before you redistribute a bundled environment. Nothing here is legal advice.

Upgrade cost is the more practical concern. Because the project pins Python 3.8 and 3.9 and ships platform-specific wheels for wxPython and ta-lib, moving to a newer interpreter is not a version bump in a file; it is a rebuild of those binary dependencies. The maintainers' own note in the README discourages forking, arguing that forks miss ongoing updates and suggesting a star instead. That is a reasonable position for a fast-moving repository, but it also means you cannot easily pin a fork and patch it without diverging from upstream.

## Conclusion

Adopt Qbot if you already write Python, want a local GUI over backtrader and qlib-style factor work, and treat the bundled strategies as reference material rather than a live trading system. Skip it if you need a supported Python 3.11 or 3.12 environment, a documented rollback path for real orders, or a project whose last release is recent: the newest release listed is qbot-pro_v1.2.1 from 2024-06-16. Before committing, verify that the GUI starts under Python 3.8, that the data interfaces you intend to use still return data, and that the broker adapter you care about is the one the repository actually ships.

## FAQ

### Which Python version does UFund-Me/Qbot require?

The README states that Qbot has only been tested under Python 3.8 and Python 3.9, and that other versions are untested. The bundled wxPython and ta-lib wheels are named for cp38 on linux_x86_64, which reinforces the 3.8 target.

### Does UFund-Me/Qbot support live trading or only backtesting?

The README describes a full loop from data acquisition through strategy development, backtesting and simulated trading to live trading, with backtesting and simulated trading placed before live access. It does not document rollback or order reconciliation for live orders.

### How do I start the UFund-Me/Qbot GUI after installing the dependencies?

After cloning the repository and installing dev/requirements.txt, export PYTHONPATH to include the repository root and backend/multi-fact/mfm_learner, then run python main.py. The README notes that on macOS you should use pythonw main.py instead.

## Sources

- [License: MIT](https://github.com/UFund-Me/Qbot/blob/main/LICENSE)
- [Project website](https://github.com/Charmve)
- [README](https://github.com/UFund-Me/Qbot/blob/main/README.md)
- [Releases](https://github.com/UFund-Me/Qbot/releases)
- [UFund-Me/Qbot on GitHub](https://github.com/UFund-Me/Qbot)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ufund-me-qbot