# intelligent-trading-bot: an ML signal generator you train yourself

> asavinov/intelligent-trading-bot is a Python project that trains machine learning models on crypto price data and turns their output into buy and sell signals. It is a research pipeline you run yourself, not a hosted trading product, and its own README warns that feature generation in batch mode can take hours.

**asavinov/intelligent-trading-bot** — Intelligent Trading Bot: Automatically generating signals and trading based on machine learning and feature engineering

- Repository: https://github.com/asavinov/intelligent-trading-bot
- Website: https://t.me/intelligent_trading_signals
- Stars: 1,876 · Forks: 409
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/asavinov-intelligent-trading-bot

## What intelligent-trading-bot actually solves, and for whom

Most retail trading bots ship a fixed strategy. This project ships a pipeline instead. The README states the aim is to develop a bot for automated trading including cryptocurrencies using machine learning algorithms and feature engineering, and the repository is organised around that: a common library, inputs, outputs, scripts, and a service. The intended reader is a developer or researcher who wants to define their own derived features, train their own models, and decide what a signal means.

The project's own framing names the hard part: keeping offline batch training and online streaming prediction consistent, so the same derived features are used in both modes. That is a real engineering problem in any ML trading system. If a feature is computed one way over historical data and another way in the live loop, the model sees a different world at prediction time than it was trained on. The README treats this separation as one of the main challenges the design addresses.

It is not aimed at someone who wants to connect an exchange account and press start. There is no hosted dashboard described, and the only always-on artefact the README advertises is a Telegram channel where the author's own configured instance posts signals for BTCUSDT on Binance at one-minute frequency.

## The batch pipeline: eight scripts from download to output

The architecture is a chain of batch scripts in the scripts module. Each one loads input files and writes output files, and all parameters come from a single JSON configuration file. The README lists the full sequence: download, merge, features, labels, train, predict, signals, output. Nothing in that chain is optional if you want signals at the end.

Download pulls historical data from the sources listed in the data_sources section of the config. The README is explicit that sources are not extendable and that only Binance and Yahoo are supported today. Merge then aligns every source file on timestamp into one table, and the README notes it also produces a continuous raster when the inputs have gaps. Features applies the feature generators named in the feature_sets section. Labels produces training targets. Train fits the models, predict scores new rows, signals converts scores into buy or sell decisions, and output delivers them.

The configuration keys the README documents are data_folder, symbol, description, and freq, where freq follows pandas conventions. The README gives BTCUSDT as the symbol format and mentions 1 minute, 1 hour, and 1 day as possible trade frequencies. Sample configuration files live in the configs folder, and the README points there rather than documenting every key.

## Installing intelligent-trading-bot and running the first training pass

There is no package on PyPI described in the README. The pyproject.toml declares the distribution name intelligent-trading-bot at version 0.8.dev, requires Python 3.12 or later, and lists the runtime dependencies including python-binance, ta-lib, scikit-learn, lightgbm, tensorflow, and keras. Install from a clone of the repository, then install the dependencies.

```bash
git clone https://github.com/asavinov/intelligent-trading-bot
cd intelligent-trading-bot
pip install -r requirements.txt
```

The requirements file carries a warning worth reading before you start. It notes that numpy, pandas, and pyarrow versions may be constrained by tensorflow, numba, and ta-lib, and that ta-lib is a Python wrapper around a native TA-Lib library, so you may need to install a platform wheel rather than rely on pip alone. A few entries in that file are commented out, including yfinance, curl-cffi, MetaTrader5, tsfresh, and seaborn, which tells you those paths exist in the code but are not part of the default install.

Once dependencies resolve, the README's batch sequence is the first real use. Every script takes the same -c flag pointing at a configuration file.

```bash
python -m scripts.download -c config.json
python -m scripts.merge -c config.json
python -m scripts.features -c config.json
python -m scripts.labels -c config.json
python -m scripts.train -c config.json
python -m scripts.predict -c config.json
python -m scripts.signals -c config.json
python -m scripts.output -c config.json
```

Expect intermediate files under the data_folder you set in the config, and a trained model artefact after the train step. The README does not document the exact output filenames, so check the outputs folder and your configured data_folder after each run.

## Where the design forces you to wait, and where it does not fit

The clearest limitation is stated by the README itself. Feature generation currently runs in a non-incremental mode: it computes features for all available input records, not just the latest update. The README says that for complex configurations this may take hours. If you are iterating on feature definitions, every iteration pays that cost.

The README also notes that online mode can compute features more efficiently when the feature generator supports it, which implies the efficiency depends on how each generator is written rather than being guaranteed by the framework. That is a gap between the two modes the project otherwise tries hard to keep aligned.

A second boundary is data sources. The README states sources are not extendable and only Binance and Yahoo downloads are possible. If your venue is not one of those, the download step cannot help you, even though the requirements file hints at MetaTrader5 support in commented lines.

Backtesting is the third place to be careful. The README describes backtesting and trade performance measurement as more difficult because it requires periodic re-training of the models. A naive backtest that trains once and replays history will not match how the service behaves over time. If your goal is a quick historical equity curve, this is the wrong tool.

## How it compares with freqtrade-style strategy bots

The obvious alternative category is a strategy-driven crypto bot such as freqtrade, where you write entry and exit rules in Python and the framework handles exchange connectivity, backtesting, and live execution. The difference in approach is where the intelligence sits. In a strategy bot, the logic is a rule you author and can read line by line. Here, the logic is a model you train, and the artefact you inspect is a feature set plus a fitted estimator.

That changes what debugging looks like. With explicit rules you can argue about whether a condition is correct. With a trained model you argue about features, labels, and the train and predict split, which is exactly the surface this project exposes through the feature_sets and labels configuration sections. The README's own separation of offline and online modes exists to make that argument tractable.

A second difference is scope of execution. The README lists customizable functions for sending signals or predictions, naming Telegram channels, an API end-point, a database, or real transactions as possibilities. That is a hook, not a built-in order manager. If you need position sizing, fee accounting, and exchange-side order lifecycle handling out of the box, a dedicated strategy framework covers more of that ground, and this project expects you to write the output function that does what you need.

## The trading service, licensing, and what upgrades cost

Online mode is handled by a trading service that the README says uses a configuration file to regularly retrieve data updates, run analysis, and send signals or execute trades. Scheduling dependencies in pyproject.toml include apscheduler, which is consistent with a periodically triggered loop, and the service directory sits alongside scripts in the package list. The README does not document the service's command line, its restart behaviour, or what happens to in-flight state when it stops, so treat operational details as something to read from the service source before you rely on it.

On licensing, the project is MIT and pyproject.toml sets license = "MIT" with license-files = ["LICENSE"]. MIT is permissive: you can use, modify, and redistribute the code, including commercially, provided the licence and copyright notice are preserved. That covers the code in this repository. It does not cover the native TA-Lib library, the exchange APIs you call, or any model weights you train on data whose terms you accepted elsewhere. Those are separate questions and not legal advice.

Upgrade cost is dominated by the pinned scientific stack. The requirements file pins numpy to the 2.x line, pandas to 3.x, and pyarrow to 25.x, and notes these versions may be constrained by tensorflow, numba, and ta-lib. The project is at 0.8.dev, so interfaces in the config schema and script flags can move. If you build on it, keep your configuration files under version control next to the code, because a version bump to the scientific stack is the most likely thing to break a working pipeline.

## Conclusion

Adopt it if you are a Python developer who wants to train and inspect your own signal models on Binance or Yahoo data and you are willing to run an eight-step batch pipeline before anything works. Do not adopt it if you want a hosted bot, a GUI, or a strategy you can switch on today: the README describes a library and a service you configure and train, not a product with a track record. Before committing, verify three things in the repository: that TA-Lib installs on your platform, that the current config files in the configs folder still match the keys the README lists, and how the service decides when to re-train models, since the README states backtesting is harder precisely because it requires periodic re-training.

## FAQ

### Do AI trading bots really work?

The repository does not make a performance claim either way, and no benchmark or track record is published in it. What the README does describe is a signalling service running in the cloud and posting to a public Telegram channel, which is presented as a way to see the kind of signals the bot can generate, not as evidence of profitability.

### Which is the most successful trading bot?

The README contains no comparison with other bots and no success metric, so this cannot be answered from it. It only describes this project's own configuration: Binance, BTCUSDT, one-minute analysis frequency, and an indicator between -1 and +1.

### Which AI trading bot is the best?

Nothing in the repository supports a ranking of trading bots. The relevant fact here is scope: this project is a Python library, a set of batch scripts, and a service, so any judgement about it depends on the features and models you configure rather than on a fixed product.

### Can ChatGPT build a trading bot?

That question is outside what the README documents, which covers only this project's own design. What it shows is the work a trading pipeline involves here: downloading and merging data, defining feature generators, generating labels, training models, and then running a service that predicts on a schedule.

## Sources

- [asavinov/intelligent-trading-bot on GitHub](https://github.com/asavinov/intelligent-trading-bot)
- [Issues](https://github.com/asavinov/intelligent-trading-bot/issues)
- [License: MIT](https://github.com/asavinov/intelligent-trading-bot/blob/master/LICENSE)
- [Project website](https://t.me/intelligent_trading_signals)
- [README](https://github.com/asavinov/intelligent-trading-bot/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/asavinov-intelligent-trading-bot